public static NSPredicate ToPredicate(this Expressions.Expression expression)
{
var json = JsonConvert.SerializeObject(expression.ToArray());
#if DEBUG
System.Diagnostics.Debug.WriteLine(json);
#endif
var obj = NSJsonSerialization.Deserialize(NSData.FromString(json), 0, out var error);
if (error != null)
{
#if DEBUG
System.Diagnostics.Debug.WriteLine(error.UserInfo.DebugDescription);
#endif
return(null);
}
if (obj is NSArray array)
{
var result = ToPredicate(array);
#if DEBUG
System.Diagnostics.Debug.WriteLine(result.ToString());
#endif
return(result);
}
return(null);
}
} // Like a linked list, points to the next else (could be an 'else if' if it has a Condition)
public IfStatement(SourceSpan span, Expressions.Expression condition, InstructionStatement body, IfStatement elseStatement)
{
this.Span = span;
this.Condition = condition;
this.Body = body;
this.ElseStatement = elseStatement;
}
public ForEachStatement(SourceSpan span, Token variable, Expressions.Expression collection, InstructionStatement body)
{
this.Span = span;
this.Variable = variable;
this.Collection = collection;
this.Body = body;
}
public CompiledNode(Expressions.Expression original, Expression tree, CodeNode[] dynamicValues)
: base(original._left, original._right, original._tempContainer == null)
{
if (_tempContainer == null)
{
_tempContainer = original._tempContainer;
}
this._original = original;
this._tree = tree;
this._dynamicValues = dynamicValues;
}
public void NullableTest()
{
var f1 = new Expressions.KVFieldExpression(1, EntityFieldType.Int32);
var f2 = new Expressions.KVFieldExpression(2, EntityFieldType.Guid);
Expressions.Expression exp = f1 > 5 & f2 == null;
var expString1 = exp.ToString();
var linqExp = exp.ToLinqExpression(TestHelper.GetMockExpressionContext());
var expString2 = linqExp.ToString();
}
public ConditionalNode(Token token, Scopes.Scope scope, Expressions.Expression expression) : base(token)
{
Expression = expression;
if (Expression.ReturnType != Nodes.Value.BoolValueNode.Type)
{
throw new Exceptions.TypeException(Expression.DefiningToken, Expression.ReturnType, Nodes.Value.BoolValueNode.Type);
}
Scope = new Scopes.Scope(scope);
}
private byte[] SerializeExpression(Expressions.Expression exp)
{
byte[] data = null;
using (var ms = new MemoryStream(1024))
{
var cf = new BinSerializer(ms);
try { cf.Serialize(exp); }
catch (Exception) { throw; }
finally { cf.Clear(); }
ms.Close();
data = ms.ToArray();
}
return(data);
}
static IOrderedQueryable <T> ApplyOrder <T>(
IQueryable <T> source,
string property,
string methodName)
{
;
string[] props = property.Split(new char[] { ',', ';' });
Type type = typeof(T);
Expressions.ParameterExpression arg =
Expressions.Expression.Parameter(type, "x");
Expressions.Expression expr = arg;
foreach (string prop in props)
{
// use reflection (not ComponentModel) to mirror LINQ
Reflection.PropertyInfo pi = type.GetProperty(prop);
if (pi == null)
{
Reflection.FieldInfo fi = type.GetField(prop);
expr = Expressions.Expression.Field(expr, fi);
type = fi.FieldType;
}
else
{
expr = Expressions.Expression.Property(expr, pi);
type = pi.PropertyType;
}
} // Next prop
Type delegateType = typeof(Func <,>).MakeGenericType(typeof(T), type);
Expressions.LambdaExpression lambda =
Expressions.Expression.Lambda(delegateType, expr, arg);
object result = typeof(Queryable).GetMethods().Single(
method => method.Name == methodName &&
method.IsGenericMethodDefinition &&
method.GetGenericArguments().Length == 2 &&
method.GetParameters().Length == 2)
.MakeGenericMethod(typeof(T), type)
.Invoke(null, new object[] { source, lambda });
return((IOrderedQueryable <T>)result);
} // End Function ApplyOrder
/// <summary>
/// Initialize a new instance of the <see cref="ClassDeclarationStatement"/> class using the specified parameters.
/// </summary>
/// <param name="linePragma">The position of the statement in the script code.</param>
/// <param name="name">The name of the class.</param>
/// <param name="super">The type expression of the super class.</param>
/// <param name="members">The members of the class.</param>
/// <exception cref="ArgumentNullException"><paramref name="linePragma"/> or <pararef name="name"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentException"><pararef name="name"/> is empty or white space.</exception>
public ClassDeclarationStatement(
LinePragma linePragma, string name, Expressions.Expression super,
MemberCollection members)
: base(linePragma)
{
if (name == null)
{
throw new ArgumentNullException();
}
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException(ExceptionResource.InvalidIdentifier);
}
Name = name;
Super = super;
Members = members;
}
public unsafe void KVFieldExpressionTest_Mvcc()
{
var data = StringHelper.FromHexString("00000020E4D8BEBE75592200000080000600004141414141310501880100000000000000000002060000414141414131");
var field = new Expressions.KVFieldExpression(Consts.EMPLOEE_NAME_ID, EntityFieldType.String);
Expressions.Expression filter = field == "AAAAA1";
var ctx = TestHelper.GetMockExpressionContext();
var body = filter.ToLinqExpression(ctx);
var exp = Expression.Lambda <KVFilterFunc>(body,
ctx.GetParameter("vp"), ctx.GetParameter("vs"), ctx.GetParameter("mv"), ctx.GetParameter("ts"));
var func = exp.Compile();
fixed(byte *ptr = data)
{
IntPtr dataPtr = new IntPtr(ptr);
Assert.True(func(dataPtr, data.Length, true, ulong.MaxValue));
}
}
public unsafe void KVFieldExpressionTest_NoneMvcc()
{
var data = StringHelper.FromHexString("400005000041646D696E800005000041646D696E");
var field = new Expressions.KVFieldExpression(Consts.EMPLOEE_NAME_ID, EntityFieldType.String);
Expressions.Expression filter = field == "Admin";
var ctx = TestHelper.GetMockExpressionContext();
var body = filter.ToLinqExpression(ctx);
var exp = Expression.Lambda <KVFilterFunc>(body,
ctx.GetParameter("vp"), ctx.GetParameter("vs"), ctx.GetParameter("mv"), ctx.GetParameter("ts"));
var func = exp.Compile();
fixed(byte *ptr = data)
{
IntPtr dataPtr = new IntPtr(ptr);
Assert.True(func(dataPtr, data.Length, false, 0));
}
}
protected override Expressions.Expression Prepare(Expressions.Expression expression) => base.Prepare(expression).ReplaceIncludeMethodCall();
public AssignmentStatement(Expressions.Expression target, Expressions.Expression value)
{
this.Target = target;
this.Value = value;
}
public InvalidExpressionException(Expressions.Expression expression) : base(string.Format($"{expression} is not valid"))
{
}
public ExpressionStatement(Expressions.Expression expression)
{
this.Expression = expression;
}
public ReturnStatement(Token returnKeyword, Expressions.Expression value)
{
this.ReturnKeyword = returnKeyword;
this.Value = value;
}
public Collection(FieldType type, Expressions.Expression size)
{
this.Size = size;
this.Type = type;
}
public AsciiString(Expressions.Expression size)
{
this.Size = size;
}
public ulong Visit(Expressions.Expression x)
{
return(1000847);
}
public DoWhileStatement(SourceSpan span, InstructionStatement body, Expressions.Expression condition)
{
this.Span = span;
this.Condition = condition;
this.Body = body;
}
public IfConditionNode(Token token, Scopes.Scope scope, Expressions.Expression expression) : base(token, scope, expression)
{
}
public VariableDeclarationStatement(SourceSpan span, Token name, Expressions.Expression initializer)
{
this.Span = span;
this.Name = name;
this.Initializer = initializer;
}
public ExpressionStatement(Expressions.Expression expression) : base(expression.token)
{
this.expression = expression;
}
