Beispiel #1
0
        public static AbstractExpression NEWARRAY(TypeMember elementType, params AbstractExpression[] items)
        {
            var context = GetContextOrThrow();

            return(PushExpression(new NewArrayExpression {
                //TODO: populate Type
                ElementType = elementType,
                Length = AbstractExpression.FromValue(items.Length),
                DimensionInitializerValues = new List <List <AbstractExpression> > {
                    items.Select(PopExpression).ToList()
                }
            }));
        }
Beispiel #2
0
 public AbstractExpression GetConstantExpression(object value)
 {
     return(AbstractExpression.FromValue(value, resolveType: this.FindType));
 }
Beispiel #3
0
 private AbstractExpression GetConstantExpression(object value)
 {
     return(AbstractExpression.FromValue(value, ResolveType));
 }
Beispiel #4
0
 public AbstractExpression GetConstantExpression(object value)
 {
     return(AbstractExpression.FromValue(value, resolveType: t => GetType(t, distance: 0)));
 }
Beispiel #5
0
        public static AbstractExpression JSON(object value)
        {
            if (value == null)
            {
                return(ConstantExpression.Null);
            }
            else if (value is AbstractExpression expression)
            {
                return(expression);
            }
            else if (value is IList list)
            {
                return(JsonOfArray(list));
            }
            else if (value is IDictionary dictionary)
            {
                return(JsonOfDictionary(dictionary));
            }
            else if (!IsScalar(value))
            {
                return(JsonOfObject(value));
            }
            else
            {
                return(new ConstantExpression {
                    Value = value
                });
            }

            bool IsScalar(object obj)
            {
                var clrType = obj.GetType();

                return(clrType.IsPrimitive || clrType.IsEnum || obj is string);
            }

            AbstractExpression JsonOfArray(IList list)
            {
                var arrayItems = list
                                 .Cast <object>()
                                 .Select(x => JSON(x))
                                 .ToList();

                return(new NewArrayExpression {
                    Length = AbstractExpression.FromValue(list.Count),
                    DimensionInitializerValues = new List <List <AbstractExpression> > {
                        arrayItems
                    }
                });
            }

            AbstractExpression JsonOfDictionary(IDictionary dictionary)
            {
                return(new ObjectInitializerExpression {
                    PropertyValues = dictionary.Keys
                                     .Cast <object>()
                                     .Select(key => new NamedPropertyValue {
                        Name = key.ToString(),
                        Value = JSON(dictionary[key])
                    }).ToList()
                });
            }

            AbstractExpression JsonOfObject(object obj)
            {
                var properties     = obj.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
                var propertyValues = properties.Select(p => new NamedPropertyValue {
                    Name  = new IdentifierName(p.Name, language: null, style: CasingStyle.Pascal),
                    Value = JSON(p.GetValue(obj))
                }).ToList();

                return(new ObjectInitializerExpression {
                    PropertyValues = propertyValues
                });
            }
        }