public void WithTwoBall_ReturnOrderedListWithTwoBall()
{
Sort actual = new Sort();
actual.Add(20);
actual.Add(10);
List <int> expected = new List <int>();
expected.Add(10);
expected.Add(20);
Assert.AreEqual(expected, actual.rack);
}
public Query <TBase, TFilter> AddSort(Expression <Func <TBase, object> > property, SortOrder order = SortOrder.Ascending)
{
Sort.Add(new SortItem <TBase> {
Order = order, Property = property
});
return(this);
}
private void addNonEmptySort(string value, SortOrder sortOrder)
{
if (String.IsNullOrEmpty(value))
{
throw Error.Format("Invalid {0} value: it cannot be empty".FormatWith(SEARCH_PARAM_SORT), null);
}
Sort.Add(Tuple.Create(value, sortOrder));
}
private void addNonEmptySort(string[] elements)
{
foreach (var e in elements)
{
var newTuple = e[0] == '-' ? Tuple.Create(e.Substring(1), SortOrder.Descending) :
Tuple.Create(e, SortOrder.Ascending);
Sort.Add(newTuple);
}
}
/// <summary>
/// Add a parameter with a given name and value.
/// </summary>
/// <param name="name">The name of the parameter</param>
/// <param name="value">The value of the parameter as a FHIR datatype or Resource</param>
/// <returns>this (Parameters), so you can chain AddParameter calls</returns>
public SearchParams Add(string name, string value)
{
if (name == null)
{
throw Error.ArgumentNull("name");
}
if (value == null)
{
throw Error.ArgumentNull("value");
}
if (String.IsNullOrEmpty(value))
{
throw Error.Argument("value", "value cannot be empty");
}
if (name == SEARCH_PARAM_QUERY)
{
Query = value;
}
else if (name == SEARCH_PARAM_TEXT)
{
Text = value;
}
else if (name == SEARCH_PARAM_CONTENT)
{
Content = value;
}
else if (name == SEARCH_PARAM_COUNT)
{
Count = Int32.Parse(value);
}
else if (name == SEARCH_PARAM_INCLUDE)
{
Include.Add(value);
}
else if (name == SEARCH_PARAM_REVINCLUDE)
{
RevInclude.Add(value);
}
else if (name.StartsWith(SEARCH_PARAM_SORT + SEARCH_MODIFIERSEPARATOR))
{
var order = name.Substring(SEARCH_PARAM_SORT.Length + 1).ToLower();
if (order.StartsWith("asc"))
{
Sort.Add(Tuple.Create(value, SortOrder.Ascending));
}
else if (order.StartsWith("desc"))
{
Sort.Add(Tuple.Create(value, SortOrder.Descending));
}
else
{
throw Error.Format("Cannot parse sort order '{0}'", null, order);
}
}
else if (name == SEARCH_PARAM_SUMMARY)
{
SummaryType st = SummaryType.False;
if (Enum.TryParse <SummaryType>(value, ignoreCase: true, result: out st))
{
Summary = st;
}
else
{
throw Error.Format("Cannot parse summary value '{0}'", null, value);
}
}
else if (name == SEARCH_PARAM_FILTER)
{
Filter = value;
}
else if (name == SEARCH_PARAM_CONTAINED)
{
if (SEARCH_CONTAINED_TRUE.Equals(value))
{
Contained = ContainedSearch.True;
}
else if (SEARCH_CONTAINED_FALSE.Equals(value))
{
Contained = ContainedSearch.False;
}
else if (SEARCH_CONTAINED_BOTH.Equals(value))
{
Contained = ContainedSearch.Both;
}
else
{
throw Error.Format("Cannot parse contained value '{0}'", null, value);
}
}
else if (name == SEARCH_PARAM_CONTAINEDTYPE)
{
if (SEARCH_CONTAINED_TYPE_CONTAINED.Equals(value))
{
ContainedType = ContainedResult.Contained;
}
else if (SEARCH_CONTAINED_TYPE_CONTAINER.Equals(value))
{
ContainedType = ContainedResult.Container;
}
else
{
throw Error.Format("Cannot parse containedType value '{0}'", null, value);
}
}
else if (name == SEARCH_PARAM_ELEMENTS)
{
Elements.AddRange(value.Split(','));
}
else
{
Parameters.Add(Tuple.Create(name, value));
}
return(this);
}
internal void AddSort(Sort orderBy, SortDirection so)
{
orderBy.Add(_col, so);
}
private void BindSortListBox()
{
Sort s = new Sort();
Binding sortBinding = new Binding();
foreach (Item item in _query.Sort)
{
foreach (string value in _query.GetFriendlyMetricsAndDimensions)
{
if (item.Value.Contains(value))
{
s.Add(item);
break;
}
}
}
_query.Sort = s;
sortBinding.Source = s;
sortingBox.SetBinding(ListBox.ItemsSourceProperty, sortBinding);
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
Trace(MethodBase.GetCurrentMethod(), node);
Expression visited = null;
try
{
visited = base.VisitMethodCall(node);
}
catch (SnNotSupportedException e)
{
throw SnExpression.CallingAsEnunerableExpectedError(node.Method.Name, e);
}
if (!(visited is MethodCallExpression methodCallExpr))
{
throw new NotSupportedException("#VisitMethodCall if visited is not null");
}
var methodName = methodCallExpr.Method.Name;
switch (methodName)
{
case "OfType":
// Do nothing. Type of expression has been changed so a TypeIs predicate will be created.
case "Where":
// do nothing
break;
case "Take":
var topExpr = GetArgumentAsConstant(methodCallExpr, 1);
this.Top = (int)topExpr.Value;
break;
case "Skip":
var skipExpr = GetArgumentAsConstant(methodCallExpr, 1);
this.Skip = (int)skipExpr.Value;
break;
case "LongCount":
case "Count":
if (methodCallExpr.Arguments.Count == 2)
{
if (_predicates.Count > 1) // There is Where in the main expression
{
CombineTwoPredicatesOnStack();
}
}
this.CountOnly = true;
break;
case "ThenBy":
case "OrderBy":
Sort.Add(CreateSortInfoFromExpr(node, false));
break;
case "ThenByDescending":
case "OrderByDescending":
Sort.Add(CreateSortInfoFromExpr(node, true));
break;
case "StartsWith":
var startsWithExpr = GetArgumentAsConstant(methodCallExpr, 0);
var startsWithArg = (string)startsWithExpr.Value;
BuildWildcardPredicate(GetPropertyName(methodCallExpr.Object), WildcardPosition.AtEnd, startsWithArg);
break;
case "EndsWith":
var endsWithExpr = GetArgumentAsConstant(methodCallExpr, 0);
var endsWithArg = (string)endsWithExpr.Value;
BuildWildcardPredicate(GetPropertyName(methodCallExpr.Object), WildcardPosition.AtStart, endsWithArg);
break;
case "Contains":
var arg0 = methodCallExpr.Arguments[0];
if (arg0 is ConstantExpression constantExpr)
{
if (constantExpr.Type != typeof(string))
{
throw new NotSupportedException(
$"Calling Contains on an instance of type {constantExpr.Type} is not supported. Allowed types: string, IEnumerable<Node>.");
}
var containsArg = (string)constantExpr.Value;
BuildWildcardPredicate(GetPropertyName(methodCallExpr.Object), WildcardPosition.AtStartAndEnd, containsArg);
break;
}
if (arg0 is MemberExpression memberExpr)
{
if (memberExpr.Type != typeof(IEnumerable <Node>))
{
throw NotSupportedException(node, "#2");
}
if (!(methodCallExpr.Arguments[1] is ConstantExpression rightConstant))
{
throw NotSupportedException(node, "#1");
}
var nodeValue = (Node)rightConstant.Value;
BuildTextPredicate(memberExpr.Member.Name, nodeValue);
break;
}
throw NotSupportedException(node, "#3");
case "FirstOrDefault":
case "First":
ElementSelection = "first";
this.Top = 1;
this.ThrowIfEmpty = methodName == "First";
if (methodCallExpr.Arguments.Count == 2)
{
if (_predicates.Count > 1)
{
CombineTwoPredicatesOnStack();
}
}
break;
case "SingleOrDefault":
case "Single":
ElementSelection = "single";
this.ThrowIfEmpty = methodName == "Single";
if (methodCallExpr.Arguments.Count == 2)
{
if (_predicates.Count > 1)
{
CombineTwoPredicatesOnStack();
}
}
break;
case "LastOrDefault":
case "Last":
ElementSelection = "last";
this.ThrowIfEmpty = methodName == "Last";
if (methodCallExpr.Arguments.Count == 2)
{
if (_predicates.Count > 1)
{
CombineTwoPredicatesOnStack();
}
}
break;
case "ElementAtOrDefault":
case "ElementAt":
ElementSelection = "elementat";
this.ThrowIfEmpty = methodName == "ElementAt";
var constExpr = GetArgumentAsConstant(methodCallExpr, 1);
var index = Convert.ToInt32(constExpr.Value);
this.Skip = index;
this.Top = 1;
break;
case "Any":
ElementSelection = "first";
this.CountOnly = true;
this.ExistenceOnly = true;
this.Top = 1;
if (methodCallExpr.Arguments.Count == 2)
{
if (_predicates.Count > 1)
{
CombineTwoPredicatesOnStack();
}
}
break;
case "Type":
var typeExpr = GetArgumentAsConstant(methodCallExpr, 0);
BuildTextPredicate("Type", (string)typeExpr.Value);
break;
case "TypeIs":
var typeIsExpr = GetArgumentAsConstant(methodCallExpr, 0);
BuildTextPredicate("TypeIs", (string)(typeIsExpr).Value);
break;
case "get_Item":
if (!(methodCallExpr.Object is ParameterExpression))
{
throw new NotSupportedException("#get_Item");
}
break;
case "startswith":
{
var fieldName = GetPropertyName(methodCallExpr.Arguments[0]);
var startswithExpr = GetArgumentAsConstant(methodCallExpr, 1);
var arg = (string)startswithExpr.Value;
BuildWildcardPredicate(fieldName, WildcardPosition.AtEnd, arg);
break;
}
case "endswith":
{
var fieldName = GetPropertyName(methodCallExpr.Arguments[0]);
var endswithExpr = GetArgumentAsConstant(methodCallExpr, 1);
var arg = (string)endswithExpr.Value;
BuildWildcardPredicate(fieldName, WildcardPosition.AtStart, arg);
break;
}
case "substringof":
{
var fieldName = GetPropertyName(methodCallExpr.Arguments[1]);
var substringofExpr = GetArgumentAsConstant(methodCallExpr, 0);
var arg = (string)substringofExpr.Value;
BuildWildcardPredicate(fieldName, WildcardPosition.AtStartAndEnd, arg);
break;
}
case "isof":
{
var isofExpr = GetArgumentAsConstant(methodCallExpr, 1);
BuildTextPredicate("TypeIs", (string)(isofExpr).Value);
break;
}
case "InFolder":
{
var infolderexpr = GetArgumentAsConstant(methodCallExpr, 0);
var folder = infolderexpr.Value;
BuildTextPredicate("InFolder", GetPath(folder, "InFolder"));
break;
}
case "InTree":
{
var intreeexpr = GetArgumentAsConstant(methodCallExpr, 0);
var folder = intreeexpr.Value;
BuildTextPredicate("InTree", GetPath(folder, "InTree"));
break;
}
case "GetType":
{
if (methodCallExpr.Object is MemberExpression member && member.Member == typeof(Content).GetProperty("ContentHandler"))
{
_predicates.Push(new ContentHandlerGetTypePredicate());
}
