Esempio n. 1
0
        Expression Value(IParser parser, Expression valueType, RuntimeSchema schema)
        {
            Debug.Assert(schema.HasValue);

            if (parser.IsBonded || (untaggedWriter && schema.IsBonded))
            {
                return(parser.Bonded(value =>
                                     writer.WriteBonded(PrunedExpression.Convert(value, typeof(IBonded)))));
            }


            if (schema.IsStruct)
            {
                return(GenerateSerialize(Struct, parser, schema));
            }

            if (schema.IsMap)
            {
                return(GenerateSerialize(Map, parser, schema));
            }

            if (schema.IsContainer)
            {
                return(GenerateSerialize(Container, parser, schema));
            }

            return(parser.Scalar(valueType, schema.TypeDef.id,
                                 value => writer.Write(value, schema.TypeDef.id)));
        }
Esempio n. 2
0
        Expression Value(IParser parser, Expression valueType)
        {
            if (parser.IsBonded)
            {
                return(parser.Bonded(value =>
                                     writer.WriteBonded(PrunedExpression.Convert(value, typeof(IBonded)))));
            }

            var switchCases = new List <DeferredSwitchCase>
            {
                PrunedExpression.SwitchCase(
                    () => GenerateSerialize(Container, parser),
                    BondDataType.BT_LIST,
                    BondDataType.BT_SET),
                PrunedExpression.SwitchCase(
                    () => GenerateSerialize(Map, parser),
                    BondDataType.BT_MAP),
                PrunedExpression.SwitchCase(
                    () => GenerateSerialize(Struct, parser),
                    BondDataType.BT_STRUCT)
            };

            switchCases.AddRange(
                from type in new[]
            {
                BondDataType.BT_BOOL,
                BondDataType.BT_UINT8,
                BondDataType.BT_UINT16,
                BondDataType.BT_UINT32,
                BondDataType.BT_UINT64,
                BondDataType.BT_FLOAT,
                BondDataType.BT_DOUBLE,
                BondDataType.BT_STRING,
                BondDataType.BT_INT8,
                BondDataType.BT_INT16,
                BondDataType.BT_INT32,
                BondDataType.BT_INT64,
                BondDataType.BT_WSTRING
            }
                select
                PrunedExpression.SwitchCase(
                    () => parser.Scalar(Expression.Constant(type), type,
                                        value => writer.Write(value, type)),
                    type));

            return(PrunedExpression.Switch(
                       valueType,
                       ThrowExpression.InvalidTypeException(valueType),
                       switchCases));
        }
Esempio n. 3
0
        Expression Value(IParser parser, Expression var, Expression valueType, Type schemaType, bool initialize)
        {
            if (schemaType.IsBondNullable())
            {
                return(Nullable(parser, var, schemaType.GetValueType(), initialize));
            }

            if (schemaType.IsBonded())
            {
                var convert = bondedConvert.MakeGenericMethod(var.Type.GetValueType());
                return(parser.Bonded(value => Expression.Assign(var, Expression.Call(value, convert))));
            }

            if (schemaType.IsBondStruct())
            {
                if (parser.IsBonded)
                {
                    var deserialize = bondedDeserialize.MakeGenericMethod(schemaType);
                    return(parser.Bonded(value => Expression.Assign(var, Expression.Call(value, deserialize))));
                }
                return(Deserialize(parser, var, var.Type, schemaType, initialize));
            }

            if (schemaType.IsBondMap())
            {
                return(Map(parser, var, schemaType, initialize));
            }

            if (schemaType.IsBondContainer())
            {
                return(Container(parser, var, schemaType, initialize));
            }

            return(parser.Scalar(valueType, schemaType.GetBondDataType(),
                                 value => typeAlias.Assign(var, PrunedExpression.Convert(value, schemaType))));
        }