public static bool Evaluate(IProcessorState processor, ref int bufferLength, ref int currentBufferPosition, out bool faulted)
{
ITokenTrie tokens = Instance.GetSymbols(processor);
ScopeBuilder <Operators, TTokens> builder = processor.ScopeBuilder(tokens, Map, DereferenceInLiteralsSetting);
bool isFaulted = false;
IEvaluable result = builder.Build(ref bufferLength, ref currentBufferPosition, x => isFaulted = true);
if (isFaulted)
{
faulted = true;
return(false);
}
try
{
object evalResult = result.Evaluate();
bool r = (bool)Convert.ChangeType(evalResult, typeof(bool));
faulted = false;
return(r);
}
catch
{
faulted = true;
return(false);
}
}
public bool Evaluate(out IJsonValue value, IJSONDocument document)
{
value = null;
IJsonValue outJsonValue;
if (!_expression.Evaluate(out outJsonValue, document))
{
return(false);
}
if (outJsonValue.DataType != FieldDataType.Array && outJsonValue.DataType != FieldDataType.Embedded)
{
return(false);
}
List <IJsonValue> returnValues = new List <IJsonValue>();
ArrayJsonValue arrayValue;
if (outJsonValue is EmbeddedList)
{
arrayValue = new ArrayJsonValue(((EmbeddedList)outJsonValue).WrapedValue.ToArray());
}
else
{
arrayValue = (ArrayJsonValue)outJsonValue;
}
for (int i = 0; i < _values.Count; i++)
{
IJsonValue compValue;
if (!_values[i].Evaluate(out compValue, document))
{
return(false);
}
if (arrayValue.Contains(compValue))
{
if (compValue.DataType == FieldDataType.Array)
{
returnValues.AddRange(((ArrayJsonValue)compValue).WrapedValue);
}
else if (compValue.DataType == FieldDataType.Embedded)
{
returnValues.AddRange(((EmbeddedList)compValue).WrapedValue);
}
else
{
returnValues.Add(compValue);
}
}
else
{
return(false);
}
}
value = new ArrayJsonValue(returnValues.ToArray());
return(true);
}
private IComparable PerformArithmeticOperation(IEvaluable evaluable, IJSONDocument document, ArithmeticOperation operation)
{
IJsonValue value1, value2;
if (!Evaluate(out value1, document))
{
return(null);
}
if (!evaluable.Evaluate(out value2, document))
{
return(null);
}
TypeCode actualType1, actualType2;
FieldDataType fieldDataType1 = JSONType.GetJSONType(value1.Value, out actualType1);
FieldDataType fieldDataType2 = JSONType.GetJSONType(value2.Value, out actualType2);
if (fieldDataType1.CompareTo(fieldDataType2) != 0)
{
return(null);
}
return(Evaluator.PerformArithmeticOperation(value1, actualType1, value2, actualType2, operation,
fieldDataType1));
}
public int Evaluate(IEvaluable evaluable, double salience)
{
if (evaluable is IAgent)
((IAgent)evaluable).Initialize(this, salience);
if (salience > 0)
return evaluable.Evaluate();
return 1;
}
public virtual IJSONDocument Transform(IJSONDocument document)
{
IJSONDocument newDocument;
if (_criteria.GetAllFields)
{
newDocument = document.Clone() as IJSONDocument;
}
else
{
newDocument = JSONType.CreateNew();
}
//if (!_criteria.IsGrouped)
// newDocument.Key = document.Key;
for (int i = 0; i < _criteria.ProjectionCount; i++)
{
IEvaluable field = _criteria[i];
IJsonValue finalValue;
if (field.Evaluate(out finalValue, document))
{
//newDocument[field.ToString()] = finalValue.Value;
var binaryExpression = field as BinaryExpression;
if (binaryExpression != null)
{
if (binaryExpression.Alias != null)
{
newDocument[binaryExpression.Alias] = finalValue.Value;
continue;
}
}
newDocument[field.CaseSensitiveInString] = finalValue.Value;
}
else
{
return(null);
}
}
if (_criteria.ContainsOrder && !_criteria.IsGrouped)
{
_criteria.OrderByField.FillWithAttributes(document, newDocument);
}
else if (_criteria.IsGrouped)
{
_criteria.GroupByField.FillWithAttributes(document, newDocument);
}
if (newDocument.Count == 0)
{
return(null);
}
return(newDocument);
}
public bool Evaluate()
{
if (evaluable != null)
{
return(evaluable.Evaluate());
}
else
{
return(evaluatelet(arena, salience, args));
}
}
public bool Evaluate(IEvaluable evaluable, double salience)
{
if (evaluable is IAgent)
{
((IAgent)evaluable).Initialize(this, salience);
}
if (salience > 0)
{
return(evaluable.Evaluate());
}
return(true);
}
private object EvaluateExpression(IEvaluable expression)
{
List <object> parameters = new List <object>();
foreach (var par in expression.Parameters)
{
var pos = ResolveRelativePosition(par);
parameters.Add(Table[pos.Column, pos.Row]);
}
return(expression.Evaluate(parameters.ToArray()));
}
public bool EvaluateOne()
{
IEvaluable evaluable = evaluables.Dequeue();
bool done = evaluable.Evaluate();
if (evaluable is IAgent)
{
if (!((IAgent)evaluable).Complete())
{
evaluables.Enqueue(evaluable);
}
}
return(done);
}
internal bool GetValue(IJSONDocument document, out AttributeValue value)
{
value = NullValue.Null;
if (document != null)
{
IJsonValue wrapedValue;
if (_fieldName.Evaluate(out wrapedValue, document))
{
if (wrapedValue.DataType != FieldDataType.Null)
{
if ((wrapedValue.DataType != FieldDataType.Array && wrapedValue.DataType != FieldDataType.Embedded))
{
value = new SingleAttributeValue((IComparable)wrapedValue.Value, _sortOrder);
}
else
{
if (_type != FieldType.Ordered)
{
value = new SingleAttributeValue(wrapedValue, _sortOrder);
}
else
{
throw new QuerySystemException(ErrorCodes.Query.ARRAY_FOUND_IN_ORDERBY);
}
}
}
else
{
value = new NullValue(_sortOrder);
}
return(true);
}
return(false);
}
return(false);
}
public bool Evaluate(out IJsonValue value, IJSONDocument document)
{
value = null;
IJsonValue outJsonValue;
//int adjustedItems = _items+1; //slice (1,0) means first item
if (!_expression.Evaluate(out outJsonValue, document))
{
return(false);
}
if (outJsonValue.DataType != FieldDataType.Array && outJsonValue.DataType != FieldDataType.Embedded)
{
return(false);
}
ArrayJsonValue arrayValue;
if (outJsonValue.DataType == FieldDataType.Embedded)
{
arrayValue = new ArrayJsonValue(((EmbeddedList)outJsonValue).WrapedValue.ToArray());
}
else
{
arrayValue = (ArrayJsonValue)outJsonValue;
}
int sourceIndex = (_start > 0) ? _start - 1 : (arrayValue.Length + _start) - _items + 1;
if (sourceIndex < 0)
{
return(false);
}
if (arrayValue.Length < sourceIndex + _items)
{
return(false);
}
IJsonValue[] returnArray = new IJsonValue[_items];
Array.Copy(arrayValue.WrapedValue, sourceIndex, returnArray, 0, _items);
value = new ArrayJsonValue(returnArray);
return(true);
}
public override bool Evaluate()
{
return(evaluable.Evaluate());
}
public void ApplyValue(IJSONDocument value)
{
IJsonValue evaluatedValue = _fieldName.Evaluate(value);
last = evaluatedValue.Value;
}
public bool Evaluate(TContext context)
{
return(!_rule.Evaluate(context));
}
public bool Evaluate(out IJsonValue value, IJSONDocument document)
{
//ReturnOperation consideration.
if (_operation == ArithmeticOperation.None && _rhs == null)
{
return(_lhs.Evaluate(out value, document));
}
IComparable opValue;
value = null;
switch (_operation)
{
case ArithmeticOperation.Addition:
opValue = _lhs.Add(_rhs, document);
if (opValue == null)
{
return(false);
}
value = JsonWrapper.Wrap(opValue);
break;
case ArithmeticOperation.Subtraction:
opValue = _lhs.Subtract(_rhs, document);
if (opValue == null)
{
return(false);
}
value = JsonWrapper.Wrap(opValue);
break;
case ArithmeticOperation.Multiplication:
opValue = _lhs.Multiply(_rhs, document);
if (opValue == null)
{
return(false);
}
value = JsonWrapper.Wrap(opValue);
break;
case ArithmeticOperation.Division:
opValue = _lhs.Divide(_rhs, document);
if (opValue == null)
{
return(false);
}
value = JsonWrapper.Wrap(opValue);
break;
case ArithmeticOperation.Modulus:
opValue = _lhs.Modulate(_rhs, document);
if (opValue == null)
{
return(false);
}
value = JsonWrapper.Wrap(opValue);
break;
}
return(true);
}