public ExprMinMaxRowNodeForgeEval(
ExprMinMaxRowNodeForge forge,
ExprEvaluator[] evaluators,
ExprForge[] forges)
{
this.forge = forge;
if (forge.EvaluationType.IsBigInteger()) {
var convertors = new BigIntegerCoercer[evaluators.Length];
for (var i = 0; i < evaluators.Length; i++) {
convertors[i] = SimpleNumberCoercerFactory.GetCoercerBigInteger(forges[i].EvaluationType);
}
computer = new MinMaxType.ComputerBigIntCoerce(
evaluators,
convertors,
forge.ForgeRenderable.MinMaxTypeEnum == MinMaxTypeEnum.MAX);
}
else if (forge.EvaluationType.IsDecimal()) {
if (forge.ForgeRenderable.MinMaxTypeEnum == MinMaxTypeEnum.MAX) {
computer = new MinMaxType.MaxComputerDecimalCoerce(evaluators);
}
else {
computer = new MinMaxType.MinComputerDecimalCoerce(evaluators);
}
}
else {
if (forge.ForgeRenderable.MinMaxTypeEnum == MinMaxTypeEnum.MAX) {
computer = new MinMaxType.MaxComputerDoubleCoerce(evaluators);
}
else {
computer = new MinMaxType.MinComputerDoubleCoerce(evaluators);
}
}
}
public static RelationalOpEnumComputer MakeBigIntegerComputer(
this RelationalOpEnum value,
Type typeOne,
Type typeTwo)
{
if (typeOne.IsBigInteger() && typeTwo.IsBigInteger())
{
return(computers.Get(new RelationalOpDesc(typeof(BigInteger), value)));
}
var convertorOne = SimpleNumberCoercerFactory.GetCoercerBigInteger(typeOne);
var convertorTwo = SimpleNumberCoercerFactory.GetCoercerBigInteger(typeTwo);
if (value == RelationalOpEnum.GT)
{
return(new RelationalOpEnumGT.BigIntConvComputer(convertorOne, convertorTwo));
}
if (value == RelationalOpEnum.LT)
{
return(new RelationalOpEnumLT.BigIntConvComputer(convertorOne, convertorTwo));
}
if (value == RelationalOpEnum.GE)
{
return(new RelationalOpEnumGE.BigIntConvComputer(convertorOne, convertorTwo));
}
return(new RelationalOpEnumLE.BigIntConvComputer(convertorOne, convertorTwo));
}
public ExprBetweenCompBigInteger(
bool lowIncluded,
bool highIncluded,
Type valueType,
Type lowerType,
Type upperType)
{
_isLowIncluded = lowIncluded;
_isHighIncluded = highIncluded;
_numberCoercerLower = SimpleNumberCoercerFactory.GetCoercerBigInteger(lowerType);
_numberCoercerUpper = SimpleNumberCoercerFactory.GetCoercerBigInteger(upperType);
_numberCoercerValue = SimpleNumberCoercerFactory.GetCoercerBigInteger(valueType);
}
private static Computer MakeBigIntegerComputer(
MathArithTypeEnum operation,
Type typeOne,
Type typeTwo)
{
if (typeOne.IsDecimal() && typeTwo.IsDecimal())
{
return(computers.Get(new MathArithDesc(typeof(decimal?), operation)));
}
if (typeOne.IsBigInteger() && typeTwo.IsBigInteger())
{
var computer = computers.Get(new MathArithDesc(typeof(BigInteger), operation));
if (computer != null)
{
return(computer);
}
}
var convertorOne = SimpleNumberCoercerFactory.GetCoercerBigInteger(typeOne);
var convertorTwo = SimpleNumberCoercerFactory.GetCoercerBigInteger(typeTwo);
if (operation == MathArithTypeEnum.ADD)
{
return(new AddBigIntConvComputer(convertorOne, convertorTwo));
}
if (operation == MathArithTypeEnum.SUBTRACT)
{
return(new SubtractBigIntConvComputer(convertorOne, convertorTwo));
}
if (operation == MathArithTypeEnum.MULTIPLY)
{
return(new MultiplyBigIntConvComputer(convertorOne, convertorTwo));
}
if (operation == MathArithTypeEnum.DIVIDE)
{
return(new DivideBigIntConvComputer(convertorOne, convertorTwo));
}
return(new ModuloLong());
}
public static CodegenExpression Codegen(
ExprMinMaxRowNodeForge forge,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var resultType = forge.EvaluationType;
var nodes = forge.ForgeRenderable.ChildNodes;
CodegenExpression expression;
if (resultType.IsBigInteger()) {
var convertors = new BigIntegerCoercer[nodes.Length];
for (var i = 0; i < nodes.Length; i++) {
convertors[i] = SimpleNumberCoercerFactory.GetCoercerBigInteger(nodes[i].Forge.EvaluationType);
}
expression = MinMaxType.ComputerBigIntCoerce.Codegen(
forge.ForgeRenderable.MinMaxTypeEnum == MinMaxTypeEnum.MAX,
codegenMethodScope,
exprSymbol,
codegenClassScope,
nodes,
convertors);
}
else if (resultType.IsDecimal()) {
if (forge.ForgeRenderable.MinMaxTypeEnum == MinMaxTypeEnum.MAX) {
expression = MinMaxType.MaxComputerDecimalCoerce.Codegen(
codegenMethodScope,
exprSymbol,
codegenClassScope,
nodes,
resultType);
}
else {
expression = MinMaxType.MinComputerDecimalCoerce.Codegen(
codegenMethodScope,
exprSymbol,
codegenClassScope,
nodes,
resultType);
}
}
else {
if (forge.ForgeRenderable.MinMaxTypeEnum == MinMaxTypeEnum.MAX) {
expression = MinMaxType.MaxComputerDoubleCoerce.Codegen(
codegenMethodScope,
exprSymbol,
codegenClassScope,
nodes,
resultType);
}
else {
expression = MinMaxType.MinComputerDoubleCoerce.Codegen(
codegenMethodScope,
exprSymbol,
codegenClassScope,
nodes,
resultType);
}
}
return expression;
}