Example #1
0
        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);
                }
            }
        }
Example #2
0
        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;
        }