Expression ThrowUnexpectedInput(Expression errorMessage)
 {
     return(ThrowExpression.InvalidDataException(
                StringExpression.Format(
                    "{0} (line {1} position {2})",
                    errorMessage,
                    Expression.Convert(Reader.LineNumber, typeof(object)),
                    Expression.Convert(Reader.LinePosition, typeof(object)))));
 }
 Expression ThrowUnexpectedState(Expression state)
 {
     return(ThrowExpression.InvalidDataException(
                StringExpression.Format(
                    "Unexpected JsonToken '{0}' at state {1} (line {2} position {3})",
                    Expression.Convert(Reader.TokenType, typeof(object)),
                    Expression.Convert(state, typeof(object)),
                    Expression.Convert(Reader.LineNumber, typeof(object)),
                    Expression.Convert(Reader.LinePosition, typeof(object)))));
 }
Exemple #3
0
        public override Expression Scalar(Expression valueType, BondDataType expectedType, ValueHandler handler)
        {
            JsonToken scalarTokenType;

            if (!ScalarTokenTypes.TryGetValue(expectedType, out scalarTokenType))
            {
                Debug.Assert(false, "Scalar should be called only on scalar expected types.");
            }

            Expression convertedValue;

            if (scalarTokenType == JsonToken.Integer)
            {
                // reader.Value is a boxed long and must be unboxed to the right type in order to
                // avoid an InvalidCastException.
                convertedValue = Expression.Convert(Reader.Value, typeof(long));
            }
            else if (scalarTokenType == JsonToken.Float)
            {
                convertedValue = Expression.Convert(Reader.Value, typeof(double));
            }
            else
            {
                convertedValue = Reader.Value;
            }

            var errorMessage =
                StringExpression.Format(
                    "Invalid input, expected JSON token of type {0}, encountered {1}",
                    Expression.Constant(scalarTokenType, typeof(object)),
                    Expression.Convert(Reader.TokenType, typeof(object)));

            var handleValue =
                Expression.IfThenElse(
                    JsonTokenEquals(scalarTokenType),
                    handler(convertedValue),
                    ThrowUnexpectedInput(errorMessage));

            // If a floating point value is expected also accept an integer
            if (scalarTokenType == JsonToken.Float)
            {
                handleValue = Expression.IfThenElse(
                    JsonTokenEquals(JsonToken.Integer),
                    handler(Expression.Convert(Reader.Value, typeof(long))),
                    handleValue);
            }

            return
                (Expression.Block(
                     handleValue,
                     Reader.Read()));
        }