public void Positionne_l_expression_en_deuxième_argument()
{
var intVar2 = new OperandeVariable(intId, "num2");
MethodExpression method = new MethodExpression(intVar, intClass.InstanceMethods[0]);
var tmp = (MethodExpression)method.Set(3, intVar2);
Assert.AreSame(intVar2, tmp.Inputs[1]);
}
public override Expression CloneExpressionOnly()
{
DelegateCreationExpression result = new DelegateCreationExpression(Type, MethodExpression.CloneExpressionOnly(), Target.CloneExpressionOnly(), null);
result.TypeIsImplicitlyInferable = this.TypeIsImplicitlyInferable;
return(result);
}
protected override IPhpValue VisitMethodExpression(MethodExpression src)
{
if (src.Method.IsStatic)
{
var phpClassName =
state.Principles.GetPhpType(src.Method.DeclaringType, true, state.Principles.CurrentType);
if (phpClassName.IsEmpty)
{
throw new Exception("phpClassName cannot be null");
}
phpClassName = phpClassName.MakeAbsolute();
var className = new PhpConstValue(phpClassName.FullName);
var methodTranslationInfo = state.Principles.GetOrMakeTranslationInfo(src.Method);
if (!src.Method.IsPublic)
{
WriteWarning(string.Format("Using not public method {0}.{1} as expression",
src.Method.DeclaringType, src.Method.Name));
}
var methodName = new PhpConstValue(methodTranslationInfo.ScriptName);
var arrayCreation = new PhpArrayCreateExpression(className, methodName);
return(SimplifyPhpExpression(arrayCreation));
}
{
// ryzykuję z this
var targetObject = new PhpThisExpression();
var methodTranslationInfo = state.Principles.GetOrMakeTranslationInfo(src.Method);
var methodName = new PhpConstValue(methodTranslationInfo.ScriptName);
var arrayCreation = new PhpArrayCreateExpression(targetObject, methodName);
return(SimplifyPhpExpression(arrayCreation));
}
}
private bool Method(FieldExpression field, out MethodExpression op)
{
var args = ReadMethodArguments();
op = new MethodExpression(field.FieldValue, args);
return(true);
}
public void Jete_exception_quand_appel_method_egal()
{
var tmp = new OperandeVariable(intId, "nom");
intClass.AddMethod("method", intId, new List<IArgument>() { registry.CreateArgument(intId) });
var tmp2 = new MethodExpression(tmp, intClass.InstanceMethods[0]);
new OperatorExpression(tmp2, OPERATOR.EQUAL);
}
public void Doit_retourner_deux_plus_inputs_pour_methode()
{
OperandeVariable operande = new OperandeVariable(classId, "var1");
cla.AddMethod("method", classId, new List<IArgument>() { registry.CreateArgument(classId)});
IExpression v = new MethodExpression(operande, registry.GetClassById(classId).InstanceMethods[0]);
Assert.AreEqual(3, v.Count);
}
public void MethodExpressionReturnsCorrectExpression()
{
// Arrange & Act
var method = new MethodExpression();
// Assert
Assert.Equal("$method", method.Expression);
}
public override Expression Clone()
{
MethodInvocationExpression result = new MethodInvocationExpression(MethodExpression.Clone() as MethodReferenceExpression, this.instructions);
result.Arguments = Arguments.Clone();
result.VirtualCall = this.VirtualCall;
return(result);
}
public Discovery()
{
Config = new Configuration();
Classes = new ClassExpression(Config);
Methods = new MethodExpression(Config);
Parameters = new ParameterSourceExpression(Config);
}
public void Doit_avoir_5_elements()
{
var tmpVar = new OperandeVariable(classId, "maVariable");
var tmp = new MethodExpression(tmpVar, registry.GetClassById(classId).InstanceMethods[0]);
var visitor = new VisualisationVisitor(ref registry);
List<IElement> lst = visitor.Visit(tmp);
Assert.AreEqual(5, lst.Count);
}
public string GetMethodName(MethodExpression method)
{
return(method switch
{
AggregateExpression aggregate => this.GetAggregateName(aggregate.Function),
SequenceExpression sequence => this.GetSequenceName(sequence),
_ => method.Name,
});
public void Doit_changer_l_element_visé_par_la_position()
{
var intVar2 = new OperandeVariable(intId, "num2");
MethodExpression method = new MethodExpression(intVar, intClass.InstanceMethods[0]);
method = (MethodExpression)method.Set(3, intVar2);
MethodExpression method2 = new MethodExpression(intVar2, intClass.InstanceMethods[0]);
method = (MethodExpression)method.Set(3, method2);
Assert.AreSame(method2, method.Inputs[1]);
}
public override Expression CloneExpressionOnly()
{
MethodInvocationExpression result = new MethodInvocationExpression(MethodExpression.CloneExpressionOnly() as MethodReferenceExpression, null)
{
Arguments = this.Arguments.CloneExpressionsOnly(), VirtualCall = this.VirtualCall, ConstraintType = this.ConstraintType
};
return(result);
}
private static void ThrowInvalidMethod(BlittableJsonReaderObject parameters, MethodExpression me, string queryText, string whereCollectionName = null)
{
if (whereCollectionName == null)
{
throw new InvalidQueryException("A 'where' clause cannot contain just a '" + me.Name + "' method", queryText, parameters);
}
throw new InvalidQueryException($"A 'where' clause after '{whereCollectionName}' cannot contain just a '" + me.Name + "' method", queryText, parameters);
}
public void Doit_changer_l_element_de_la_methode_visé_par_la_position()
{
MethodExpression method = new MethodExpression(intVar, intClass.InstanceMethods[0]);
MethodExpression method2 = new MethodExpression(intVar, intClass.InstanceMethods[0]);
method = (MethodExpression)method.Set(3, method2);
method = (MethodExpression)method.Set(5, intVar);
Assert.AreSame(intVar, ((MethodExpression)(method.Inputs[1])).Inputs[0]);
}
public void Doit_avoir_des_positions_croissantes()
{
var tmpVar = new OperandeVariable(classId, "maVariable");
var tmp = new MethodExpression(tmpVar, registry.GetClassById(classId).InstanceMethods[0]);
var visitor = new VisualisationVisitor(ref registry);
List<IElement> lst = visitor.Visit(tmp);
for(int i = 0; i<lst.Count; i++)
{
Assert.AreEqual(i, lst[i].Position);
}
}
public void Doit_ajouter_les_inputs()
{
cla.AddMethod("method2", classId, new List<IArgument>() { registry.CreateArgument(classId), registry.CreateArgument(classId) });
var tmpVar = new OperandeVariable(classId, "maVariable");
var tmp = new MethodExpression(tmpVar, registry.GetClassById(classId).InstanceMethods[1]);
tmp = (MethodExpression)tmp.Set(2, tmpVar);
tmp = (MethodExpression)tmp.Set(3, tmpVar);
var visitor = new VisualisationVisitor(ref registry);
List<IElement> lst = visitor.Visit(tmp);
Assert.AreEqual(7, lst.Count);
}
/// <summary>
/// Visitor pattern method for <see cref="MethodExpression"/>.
/// </summary>
/// <param name="expression">The MethodExpression that is being visited.</param>
/// <exception cref="ArgumentNullException"><paramref name="expression"/> is null</exception>
public override bool Visit(MethodExpression expression)
{
bool result = VisitExpressionList(expression.Arguments);
if (expression.Instance != null)
{
bool instanceNeedsRewrite = VisitExpression(expression.Instance);
result = result || instanceNeedsRewrite;
}
return(result);
}
/// <summary>
/// Visitor pattern method for <see cref="MethodExpression"/>.
/// </summary>
/// <param name="expression">The MethodExpression that is being visited.</param>
/// <exception cref="ArgumentNullException"><paramref name="expression"/> is null</exception>
public override void Visit(MethodExpression expression)
{
// #433613: PreSharp warning 56506: Parameter 'expression' to this public method must be validated: A null-dereference can occur here.
ADP1.CheckArgumentNull(expression, "expression");
if (expression.Instance != null)
{
VisitExpression(expression.Instance);
}
VisitExpressionList(expression.Arguments);
}
public override void Visit(MethodExpression e)
{
Begin(e);
Dump(e.Method);
Dump(e.Arguments, "Arguments", "Argument");
if (e.Instance != null)
{
Dump(e.Instance, "Instance");
}
End(e);
}
public Convention()
{
Config = new Configuration();
Classes = new ClassExpression(Config);
Methods = new MethodExpression(Config);;
Parameters = new ParameterSourceExpression(Config);
CaseExecution = new CaseBehaviorExpression(Config);
FixtureExecution = new FixtureBehaviorExpression(Config);
ClassExecution = new ClassBehaviorExpression(Config);
HideExceptionDetails = new AssertionLibraryExpression(Config);
}
public Convention()
{
Config = new Configuration();
Classes = new ClassExpression(Config);
Methods = new MethodExpression(Config);
Parameters = new ParameterSourceExpression(Config);
CaseExecution = new CaseBehaviorExpression(Config);
FixtureExecution = new FixtureBehaviorExpression(Config);
ClassExecution = new ClassBehaviorExpression(Config);
HideExceptionDetails = new AssertionLibraryExpression(Config);
}
public void Doit_retourner_elements_sans_constructeur_et_word_new()
{
var tmpCla = new OperandeClass(classId);
var tmp = new MethodExpression(tmpCla, registry.GetClassById(classId).Constructors[0]);
var visitor = new VisualisationVisitor(ref registry);
List<IElement> lst = visitor.Visit(tmp);
Assert.AreEqual(ELEMENT_TYPE.WORD, lst[0].ElementType);
Assert.AreEqual(ELEMENT_TYPE.CLASS, lst[1].ElementType);
Assert.AreEqual(ELEMENT_TYPE.METHOD_BEGIN, lst[2].ElementType);
Assert.AreEqual(ELEMENT_TYPE.ARGUMENT, lst[3].ElementType);
Assert.AreEqual(ELEMENT_TYPE.METHOD_END, lst[4].ElementType);
}
public void Doit_retourner_id_class_que_methode()
{
var visitor = new ReturnVisitor(ref registry);
var tmpId = registry.AddPrimitiveClass("string", DATA_TYPE.STRING);
cla.AddMethod("method", tmpId, new System.Collections.Generic.List<ClassesRegistry.Method.Argument.IArgument>());
var tmp = new OperandeVariable(classId, "num");
var tmp2 = new MethodExpression(tmp, registry.GetClassById(classId).InstanceMethods[0]);
Assert.AreEqual(tmpId, visitor.Visit(tmp2));
}
public string GetMethodName(MethodExpression method)
{
switch (method)
{
case AggregateExpression aggregate:
return(this.GetAggregateName(aggregate.Function));
case SequenceExpression sequence:
return(this.GetSequenceName(sequence));
default:
return(method.Name);
}
}
public string GetMethodName(MethodExpression method)
{
switch (method)
{
case AggregateExpression aggregate:
return(aggregate.Method.ToString());
case SequenceExpression sequence:
return(sequence.Method.ToString());
default:
return(method.Name);
}
}
protected SourceLocation DoParseExpression(ScriptingContext context,
LocationType type, string arg)
{
F.Expression expr = context.ParseExpression(arg);
MethodExpression mexpr = expr.ResolveMethod(context, type);
if (mexpr != null)
{
return(mexpr.EvaluateSource(context));
}
else
{
return(context.FindMethod(arg));
}
}
private static Shape HandleWkt(Query query, MethodExpression expression, QueryMetadata metadata, BlittableJsonReaderObject parameters, string fieldName,
SpatialField spatialField)
{
var wktValue = GetValue(fieldName, query, metadata, parameters, (ValueExpression)expression.Arguments[0]);
AssertValueIsString(fieldName, wktValue.Type);
SpatialUnits?spatialUnits = null;
if (expression.Arguments.Count == 2)
{
spatialUnits = GetSpatialUnits(query, expression.Arguments[3] as ValueExpression, metadata, parameters, fieldName);
}
return(spatialField.ReadShape((string)wktValue.Value, spatialUnits));
}
public static int LastWithCount(MethodExpression expression, string queryText, BlittableJsonReaderObject parameters)
{
try
{
if (expression.Arguments.Count != 1)
{
throw new InvalidOperationException("Method 'last()' with count expects one arguments to be provided");
}
var duration = (int)Helpers.GetLong(expression.Arguments[0], parameters);
return(duration);
}
catch (Exception e)
{
throw new InvalidQueryException("Could not parse last() method.", queryText, parameters, e);
}
}
public override TreeNode Visit(MethodExpression e)
{
TreeNode retInfo = null;
retInfo = new TreeNode(".");
AppendType(retInfo, e.Method.DefiningType);
retInfo.Text.Append(".");
retInfo.Text.Append(e.Method.Name);
AppendParameters(retInfo, e.Method.Parameters);
if (e.Instance != null)
{
retInfo.Children.Add(this.Visit("Instance", e.Instance));
}
AppendArguments(retInfo, e.Method.Parameters, e.Arguments);
return(retInfo);
}
/// <summary>
/// Update game logic
/// </summary>
/// <param name="deltaTime">Time since last frame</param>
private void Update(float deltaTime)
{
// Update active scene
SceneManager.Instance.CurrentScene.Update(deltaTime);
// Request window redraw
Invalidate();
timer += deltaTime;
if (Input.IsKeyDown(System.Windows.Forms.Keys.C))
{
string line = Console.ReadLine();
IExpression exp = new StringExpression(line);
IExpression query = new MethodExpression(exp);
Console.WriteLine(query.executeMethod());
}
}
public static (TimeSeriesRangeType Type, int Count) ParseCount(MethodExpression expression, string queryText, BlittableJsonReaderObject parameters = null)
{
TimeSeriesRangeType type;
int count;
switch (QueryMethod.GetMethodType(expression.Name.ToString()))
{
case MethodType.Last:
type = TimeSeriesRangeType.Last;
count = QueryMethod.TimeSeries.LastWithCount(expression, queryText, parameters);
break;
default:
throw new InvalidQueryException($"Got invalid type {expression.Name}.", queryText, parameters);
}
return(type, count);
}
private static Lucene.Net.Search.Query HandleEndsWith(Query query, MethodExpression expression, QueryMetadata metadata, BlittableJsonReaderObject parameters)
{
var fieldName = ExtractIndexFieldName(query, parameters, expression.Arguments[0], metadata);
var(value, valueType) = GetValue(fieldName, query, metadata, parameters, (ValueExpression)expression.Arguments[1]);
if (valueType != ValueTokenType.String)
{
ThrowMethodExpectsArgumentOfTheFollowingType("endsWith", ValueTokenType.String, valueType, metadata.QueryText, parameters);
}
var valueAsString = GetValueAsString(value);
valueAsString = string.IsNullOrEmpty(valueAsString)
? LuceneQueryHelper.Asterisk
: valueAsString.Insert(0, LuceneQueryHelper.Asterisk);
return(LuceneQueryHelper.Term(fieldName, valueAsString, LuceneTermType.WildCard));
}
public static TimeValue LastWithTime(MethodExpression expression, string queryText, BlittableJsonReaderObject parameters)
{
try
{
if (expression.Arguments.Count != 2)
{
throw new InvalidOperationException("Method 'last()' expects two arguments to be provided");
}
var duration = Helpers.GetLong(expression.Arguments[0], parameters);
var timeValueUnitAsString = Helpers.GetString(expression.Arguments[1], parameters);
var offset = 0;
return(RangeGroup.ParseTimePeriodFromString(duration, timeValueUnitAsString, ref offset));
}
catch (Exception e)
{
throw new InvalidQueryException("Could not parse last() method.", queryText, parameters, e);
}
}
private static Lucene.Net.Search.Query HandleLucene(Query query, MethodExpression expression, QueryMetadata metadata, BlittableJsonReaderObject parameters,
Analyzer analyzer)
{
var fieldName = ExtractIndexFieldName(query, parameters, expression.Arguments[0], metadata);
var(value, valueType) = GetValue(fieldName, query, metadata, parameters, (ValueExpression)expression.Arguments[1]);
if (valueType != ValueTokenType.String)
{
ThrowMethodExpectsArgumentOfTheFollowingType("lucene", ValueTokenType.String, valueType, metadata.QueryText, parameters);
}
if (metadata.IsDynamic)
{
fieldName = new QueryFieldName(AutoIndexField.GetSearchAutoIndexFieldName(fieldName.Value), fieldName.IsQuoted);
}
var parser = new Lucene.Net.QueryParsers.QueryParser(Version.LUCENE_29, fieldName, analyzer);
return(parser.Parse(GetValueAsString(value)));
}
private static Shape HandleCircle(Query query, MethodExpression expression, QueryMetadata metadata, BlittableJsonReaderObject parameters, string fieldName,
SpatialField spatialField)
{
var radius = GetValue(fieldName, query, metadata, parameters, (ValueExpression)expression.Arguments[0]);
AssertValueIsNumber(fieldName, radius.Type);
var latitute = GetValue(fieldName, query, metadata, parameters, (ValueExpression)expression.Arguments[1]);
AssertValueIsNumber(fieldName, latitute.Type);
var longitude = GetValue(fieldName, query, metadata, parameters, (ValueExpression)expression.Arguments[2]);
AssertValueIsNumber(fieldName, longitude.Type);
SpatialUnits?spatialUnits = null;
if (expression.Arguments.Count == 4)
{
spatialUnits = GetSpatialUnits(query, expression.Arguments[3] as ValueExpression, metadata, parameters, fieldName);
}
return(spatialField.ReadCircle(Convert.ToDouble(radius.Value), Convert.ToDouble(latitute.Value), Convert.ToDouble(longitude.Value), spatialUnits));
}
/// <summary> /// Visitor pattern method for MethodExpression. /// </summary> /// <param name="expression">The MethodExpression that is being visited.</param> public abstract void Visit(MethodExpression expression);
/// <summary>
/// Visitor pattern method for <see cref="MethodExpression"/>.
/// </summary>
/// <param name="expression">The MethodExpression that is being visited.</param>
/// <exception cref="ArgumentNullException"><paramref name="expression"/> is null</exception>
public override void Visit(MethodExpression expression)
{
// #433613: PreSharp warning 56506: Parameter 'expression' to this public method must be validated: A null-dereference can occur here.
ADP1.CheckArgumentNull(expression, "expression");
if (expression.Instance != null)
{
VisitExpression(expression.Instance);
}
VisitExpressionList(expression.Arguments);
}
public override void Visit(MethodExpression e)
{
Begin(e);
Dump(e.Method);
Dump(e.Arguments, "Arguments", "Argument");
if (e.Instance != null)
{
Dump(e.Instance, "Instance");
}
End(e);
}
private static Lucene.Net.Search.Query HandleExact(JsonOperationContext context, Query query, MethodExpression expression, QueryMetadata metadata,
BlittableJsonReaderObject parameters, Analyzer analyzer, Func <string, SpatialField> getSpatialField)
{
return(ToLuceneQuery(context, query, expression.Arguments[0], metadata, parameters, analyzer, getSpatialField, exact: true));
}
public IPhpValue TranslateToPhp(IExternalTranslationContext ctx, MethodExpression src)
{
return(null);
}
private static void GenerateMethodExpression(ScriptGenerator generator, MemberSymbol symbol, MethodExpression expression)
{
ScriptTextWriter writer = generator.Writer;
if (expression.Method.SkipGeneration)
{
// If this method is to be skipped from generation, just generate the
// left-hand-side object reference, and skip everything past it, including
// the dot.
GenerateExpression(generator, symbol, expression.ObjectReference);
return;
}
if (expression.ObjectReference is BaseExpression)
{
Debug.Assert(expression.Method.IsExtension == false);
writer.Write(((BaseExpression)expression.ObjectReference).EvaluatedType.FullGeneratedName);
writer.Write(".prototype.");
writer.Write(expression.Method.GeneratedName);
writer.Write(".call(");
writer.Write(generator.CurrentImplementation.ThisIdentifier);
if ((expression.Parameters != null) && (expression.Parameters.Count != 0))
{
writer.Write(", ");
GenerateExpressionList(generator, symbol, expression.Parameters);
}
writer.Write(")");
}
else
{
if (expression.Method.IsAliased)
{
writer.Write(expression.Method.Alias);
writer.Write("(");
if ((expression.Method.Visibility & MemberVisibility.Static) == 0)
{
GenerateExpression(generator, symbol, expression.ObjectReference);
if ((expression.Parameters != null) && (expression.Parameters.Count != 0))
{
writer.Write(", ");
}
}
if ((expression.Parameters != null) && (expression.Parameters.Count != 0))
{
GenerateExpressionList(generator, symbol, expression.Parameters);
}
writer.Write(")");
}
else
{
if (expression.Method.IsExtension)
{
Debug.Assert(expression.Method.Parent.Type == SymbolType.Class);
string extendee = ((ClassSymbol)expression.Method.Parent).Extendee;
Debug.Assert(String.IsNullOrEmpty(extendee) == false);
writer.Write(extendee);
writer.Write(".");
}
else
{
GenerateExpression(generator, symbol, expression.ObjectReference);
if (expression.Method.GeneratedName.Length != 0)
{
writer.Write(".");
}
}
if (expression.Method.GeneratedName.Length != 0)
{
writer.Write(expression.Method.GeneratedName);
}
writer.Write("(");
if (expression.Parameters != null)
{
GenerateExpressionList(generator, symbol, expression.Parameters);
}
writer.Write(")");
}
}
}
private static Lucene.Net.Search.Query HandleSearch(Query query, MethodExpression expression, QueryMetadata metadata, BlittableJsonReaderObject parameters,
Analyzer analyzer)
{
QueryFieldName fieldName;
if (expression.Arguments[0] is FieldExpression ft)
{
fieldName = ExtractIndexFieldName(query, parameters, ft, metadata);
}
else if (expression.Arguments[0] is ValueExpression vt)
{
fieldName = ExtractIndexFieldName(vt, metadata, parameters);
}
else
{
throw new InvalidOperationException("search() method can only be called with an identifier or string, but was called with " + expression.Arguments[0]);
}
var(value, valueType) = GetValue(fieldName, query, metadata, parameters, (ValueExpression)expression.Arguments[1]);
if (valueType != ValueTokenType.String)
{
ThrowMethodExpectsArgumentOfTheFollowingType("search", ValueTokenType.String, valueType, metadata.QueryText, parameters);
}
Debug.Assert(metadata.IsDynamic == false || metadata.WhereFields[fieldName].IsFullTextSearch);
var valueAsString = GetValueAsString(value);
var values = valueAsString.Split(' ');
if (metadata.IsDynamic)
{
fieldName = new QueryFieldName(AutoIndexField.GetSearchAutoIndexFieldName(fieldName.Value), fieldName.IsQuoted);
}
if (values.Length == 1)
{
var nValue = values[0];
return(LuceneQueryHelper.AnalyzedTerm(fieldName, nValue, GetTermType(nValue), analyzer));
}
var occur = Occur.SHOULD;
if (expression.Arguments.Count == 3)
{
var fieldExpression = (FieldExpression)expression.Arguments[2];
if (fieldExpression.Compound.Count != 1)
{
ThrowInvalidOperatorInSearch(metadata, parameters, fieldExpression);
}
var op = fieldExpression.Compound[0];
if (string.Equals("AND", op, StringComparison.OrdinalIgnoreCase))
{
occur = Occur.MUST;
}
else if (string.Equals("OR", op, StringComparison.OrdinalIgnoreCase))
{
occur = Occur.SHOULD;
}
else
{
ThrowInvalidOperatorInSearch(metadata, parameters, fieldExpression);
}
}
var q = new BooleanQuery();
foreach (var v in values)
{
q.Add(LuceneQueryHelper.AnalyzedTerm(fieldName, v, GetTermType(v), analyzer), occur);
}
return(q);
LuceneTermType GetTermType(string termValue)
{
if (string.IsNullOrEmpty(termValue))
{
return(LuceneTermType.String);
}
if (termValue[0] == LuceneQueryHelper.AsteriskChar)
{
return(LuceneTermType.WildCard);
}
if (termValue[termValue.Length - 1] == LuceneQueryHelper.AsteriskChar)
{
if (termValue[termValue.Length - 2] != '\\')
{
return(LuceneTermType.Prefix);
}
}
return(LuceneTermType.String);
}
}
public void Jete_exception_si_position_inattendue()
{
MethodExpression method = new MethodExpression(intVar, intClass.InstanceMethods[0]);
Assert.AreSame(intVar, method.Set(1, intVar));
}
private static Lucene.Net.Search.Query HandleSpatial(Query query, MethodExpression expression, QueryMetadata metadata, BlittableJsonReaderObject parameters,
MethodType spatialMethod, Func <string, SpatialField> getSpatialField)
{
string fieldName;
if (metadata.IsDynamic == false)
{
fieldName = ExtractIndexFieldName(query, parameters, expression.Arguments[0], metadata);
}
else
{
var spatialExpression = (MethodExpression)expression.Arguments[0];
fieldName = spatialExpression.GetText();
}
var shapeExpression = (MethodExpression)expression.Arguments[1];
var distanceErrorPct = Constants.Documents.Indexing.Spatial.DefaultDistanceErrorPct;
if (expression.Arguments.Count == 3)
{
var distanceErrorPctValue = GetValue(fieldName, query, metadata, parameters, (ValueExpression)expression.Arguments[2]);
AssertValueIsNumber(fieldName, distanceErrorPctValue.Type);
distanceErrorPct = Convert.ToDouble(distanceErrorPctValue.Value);
}
var spatialField = getSpatialField(fieldName);
var methodName = shapeExpression.Name;
var methodType = QueryMethod.GetMethodType(methodName);
Shape shape = null;
switch (methodType)
{
case MethodType.Circle:
shape = HandleCircle(query, shapeExpression, metadata, parameters, fieldName, spatialField);
break;
case MethodType.Wkt:
shape = HandleWkt(query, shapeExpression, metadata, parameters, fieldName, spatialField);
break;
default:
QueryMethod.ThrowMethodNotSupported(methodType, metadata.QueryText, parameters);
break;
}
Debug.Assert(shape != null);
SpatialOperation operation = null;
switch (spatialMethod)
{
case MethodType.Within:
operation = SpatialOperation.IsWithin;
break;
case MethodType.Contains:
operation = SpatialOperation.Contains;
break;
case MethodType.Disjoint:
operation = SpatialOperation.IsDisjointTo;
break;
case MethodType.Intersects:
operation = SpatialOperation.Intersects;
break;
default:
QueryMethod.ThrowMethodNotSupported(spatialMethod, metadata.QueryText, parameters);
break;
}
Debug.Assert(operation != null);
var args = new SpatialArgs(operation, shape)
{
DistErrPct = distanceErrorPct
};
return(spatialField.Strategy.MakeQuery(args));
}
public void Retourne_l_element_positionné_quand_position_zero()
{
MethodExpression method = new MethodExpression(intVar, intClass.InstanceMethods[0]);
Assert.AreSame(intVar, method.Set(0, intVar));
}
