forked from ThatRendle/Simple.Data
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathSimpleExpression.cs
More file actions
144 lines (126 loc) · 4.85 KB
/
SimpleExpression.cs
File metadata and controls
144 lines (126 loc) · 4.85 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
namespace Simple.Data
{
/// <summary>
/// Represents a query criteria expression.
/// </summary>
public class SimpleExpression
{
public static readonly SimpleExpression Empty = new SimpleEmptyExpression();
private readonly object _leftOperand;
private readonly object _rightOperand;
private readonly SimpleExpressionType _type;
public SimpleExpression(object leftOperand, object rightOperand, SimpleExpressionType type)
{
_leftOperand = leftOperand;
_type = type;
_rightOperand = rightOperand;
}
/// <summary>
/// Gets the left operand. This may be a <see cref="ObjectReference"/>, a primitive value, or a nested <see cref="SimpleExpression"/>.
/// </summary>
/// <value>The left operand.</value>
public object LeftOperand
{
get { return _leftOperand; }
}
/// <summary>
/// Gets the type of expression represented.
/// </summary>
/// <value>The type.</value>
public SimpleExpressionType Type
{
get { return _type; }
}
/// <summary>
/// Gets the right operand. This may be a <see cref="ObjectReference"/>, a primitive value, or a nested <see cref="SimpleExpression"/>.
/// </summary>
/// <value>The right operand.</value>
public object RightOperand
{
get { return _rightOperand; }
}
public IEnumerable<object> GetValues()
{
return GetValues(_leftOperand).Concat(GetValues(_rightOperand));
}
public IEnumerable<T> GetOperandsOfType<T>()
{
return GetOperandsOfType<T>(_leftOperand).Concat(GetOperandsOfType<T>(_rightOperand));
}
private IEnumerable<T> GetOperandsOfType<T>(object operand)
{
var expression = operand as SimpleExpression;
if (expression != null)
{
return expression.GetOperandsOfType<T>();
}
if (operand is T)
{
return Yield(operand).Cast<T>();
}
return Enumerable.Empty<T>();
}
private static IEnumerable<object> GetValues(object operand)
{
if (ReferenceEquals(operand, null)) return Yield(null);
if (CommonTypes.Contains(operand.GetType())) return Yield(operand);
if (operand is SimpleReference)
{
return Enumerable.Empty<object>();
}
var expression = operand as SimpleExpression;
if (expression != null)
{
return expression.GetValues();
}
var function = operand as SimpleFunction;
if (function != null)
{
return function.Args;
}
return Yield(operand);
}
private static IEnumerable<object> Yield(object value)
{
yield return value;
}
/// <summary>
/// Implements the operator &. In Simple.Data, this is used as a standard AND operator in place of &&.
/// </summary>
/// <param name="left">The left expression.</param>
/// <param name="right">The right expression.</param>
/// <returns>A new <see cref="SimpleExpression"/> combining both expressions with an AND operator.</returns>
public static SimpleExpression operator &(SimpleExpression left, SimpleExpression right)
{
if (left == Empty) return right;
if (right == Empty) return left;
return new SimpleExpression(left, right, SimpleExpressionType.And);
}
/// <summary>
/// Implements the operator |. In Simple.Data, this is used as a standard OR operator in place of ||.
/// </summary>
/// <param name="left">The left expression.</param>
/// <param name="right">The right expression.</param>
/// <returns>A new <see cref="SimpleExpression"/> combining both expressions with an OR operator.</returns>
public static SimpleExpression operator |(SimpleExpression left, SimpleExpression right)
{
if (left == Empty) return right;
if (right == Empty) return left;
return new SimpleExpression(left, right, SimpleExpressionType.Or);
}
public static bool operator true(SimpleExpression foo)
{
return false;
}
public static bool operator false(SimpleExpression foo)
{
return false;
}
}
}