/// <summary>
/// Добавить объект
/// </summary>
/// <param name="obj">Значение</param>
public void Enqueue(object obj)
{
var node = new SortNode(obj as IComparable);
root = (root == null) ? node : root.Put(node);
Count++;
}
/// <summary>
/// Process the sorting parameters and create the array of sort nodes that will be used by query processors
/// </summary>
/// <param name="processedQueryParameters"></param>
/// <param name="castGeneralQueryParameters"></param>
private void ProcessSortingParams(QueryParameters processedQueryParameters, JQueryDataTableParams castGeneralQueryParameters)
{
// Reference all the bound property names as sent from the client
var boundDataProperties = castGeneralQueryParameters.amDataProp;
var sortPriority = 0;
// Reference the sorting directions array
var sortingDirections = castGeneralQueryParameters.asSortDir;
foreach (var columBeingSorted in castGeneralQueryParameters.aiSortCol)
{
var sortNode = new SortNode
{
SortTarget = boundDataProperties[columBeingSorted],
SortPriority = sortPriority++,
SortDirection =
GetSortDirection(sortingDirections, columBeingSorted) == "asc"
? SortDirection.Asc
: SortDirection.Desc
};
// Set the sorting target
processedQueryParameters.SortNodes.Add(sortNode);
}
}
public void SortNodeTest()
{
var node = new SortNode
{
Sorts =
{
new ExpressionWithSortOrder
{
Expression = new ColumnReferenceExpression{
MultiPartIdentifier = new MultiPartIdentifier{
Identifiers ={ new Identifier {
Value = "value1"
} }
}
},
SortOrder = SortOrder.Ascending
},
new ExpressionWithSortOrder
{
Expression = new ColumnReferenceExpression{
MultiPartIdentifier = new MultiPartIdentifier{
Identifiers ={ new Identifier {
Value = "value2"
} }
}
},
SortOrder = SortOrder.Descending
}
},
Source = new ConstantScanNode
{
Values =
{
new Entity {
["value1"] = new SqlString("hello", CultureInfo.CurrentCulture.LCID, SqlCompareOptions.IgnoreCase | SqlCompareOptions.IgnoreNonSpace), ["value2"] = new SqlInt32(1), ["expectedorder"] = new SqlInt32(2)
},
new Entity {
["value1"] = new SqlString("world", CultureInfo.CurrentCulture.LCID, SqlCompareOptions.IgnoreCase | SqlCompareOptions.IgnoreNonSpace), ["value2"] = new SqlInt32(2), ["expectedorder"] = new SqlInt32(3)
},
new Entity {
["value1"] = new SqlString("Hello", CultureInfo.CurrentCulture.LCID, SqlCompareOptions.IgnoreCase | SqlCompareOptions.IgnoreNonSpace), ["value2"] = new SqlInt32(3), ["expectedorder"] = new SqlInt32(1)
}
},
Schema =
{
["value1"] = typeof(SqlString),
["value2"] = typeof(SqlInt32),
["expectedorder"] = typeof(SqlInt32)
}
}
};
var results = node.Execute(_dataSources, new StubOptions(), null, null)
.Select(e => e.GetAttributeValue <SqlInt32>("expectedorder").Value)
.ToArray();
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, results);
}
public void Successfully_SortDescending()
{
var node = new SortNode(SortDirection.Descending)
{
Expression = _4d20
};
EvaluateNode(node, Data(SortConf), 4, "4d20.sortDesc() => 18 + 9 + 6 + 3 => 36");
}
/// <summary>
/// Process sorting parameters on the queryable collection based on the query parameters sort nodes, created from the
/// appropriate parameter processors.
/// </summary>
/// <param name="queryable"></param>
/// <param name="queryParameters"></param>
/// <returns></returns>
private static IQueryable <T> ProcessSorting(IQueryable <T> queryable, QueryParameters queryParameters)
{
// If there is no sorting nodes set for any reason from the client
// we will sort on the default initial property
if (queryParameters.SortNodes.Count == 0)
{
// Get the first property name used in initial ordering
var type = typeof(T);
var firstPropertyName = type.GetProperties()[0].Name;
// sort the queryable by the first property of the type
queryable = queryable.OrderBy(x => firstPropertyName);
}
else
{
// Order the sort nodes based on priority. Bassically gives back the same order
// because of no extra data beeing sent from client for priority.
var orderedSortNodes = queryParameters.SortNodes.OrderBy(x => x.SortPriority);
foreach (var orderedSortNode in orderedSortNodes)
{
SortNode node = orderedSortNode;
var type = typeof(T);
var sortProperty = type.GetProperties().FirstOrDefault(x => x.Name == node.SortTarget);
if (sortProperty == null)
{
// Try and see if there is a property from a processed sort target for rebound Model Properties using the _ splitter
var procSortTarget = node.SortTarget.Split('_')[0];
sortProperty = type.GetProperties().FirstOrDefault(x => x.Name == procSortTarget);
// if we still dont have a sort property we can continue
if (sortProperty == null)
{
continue;
}
}
// Apply the sorting on the target depending on the sort direction
if (orderedSortNode.SortDirection == SortDirection.Asc)
{
queryable = queryable.OrderBy(sortProperty.Name);
}
else
{
queryable = queryable.OrderBy(sortProperty.Name + " DESC");
}
}
}
return(queryable);
}
public static SortDefinition <T> OrderBy <T>(SortNode sort)
{
var propertyName = string.Join(".", sort.Path);
if (sort.Order == SortOrder.Ascending)
{
return(Builders <T> .Sort.Ascending(propertyName));
}
else
{
return(Builders <T> .Sort.Descending(propertyName));
}
}
public static IEnumerable <T> FloodFill(T start, int maxCost = -1, int maxDepth = -1)
{
HashSet <T> domain = new HashSet <T>();
List <SortNode> open = new List <SortNode>();
open.Add(new SortNode()
{
Node = start, Level = 1
});
domain.Add(open[0].Node);
//Profiler.BeginSample("GraphMethods.FloodFill");
while (open.Count > 0)
{
open.Sort();
SortNode current = open[0];
open.RemoveAt(0);
//domain.Add(current.Node);
if (maxDepth == -1 || current.Level < maxDepth)
{
foreach (T neighbor in current.Node.GetNeighbors())
{
if (domain.Contains(neighbor))
{
continue;
}
int tentativeGScore = current.GScore + current.Node.GetEdgeCost(neighbor);
if (maxCost == -1 || tentativeGScore < maxCost)
{
domain.Add(neighbor);
open.Add(new SortNode()
{
Node = neighbor,
GScore = tentativeGScore,
FScore = tentativeGScore,
Level = current.Level + 1
});
}
}
}
}
//Profiler.EndSample();
return(domain);
}
/// <summary>
/// Извлечь значение
/// </summary>
/// <param name="ptr">Новая ссылка на корень ветви</param>
/// <returns>"Минимальное значение"</returns>
public Object Get(out SortNode ptr)
{
if (left == null)
{
ptr = null;
}
else if (right == null)
{
ptr = left;
}
else
{
ptr = (left.Value.CompareTo(right.Value) < 0) ? left.Put(right) : right.Put(left);
}
return(Value);
}
/// <summary>
/// Добавить узел
/// </summary>
/// <param name="node">Добавляемый узел</param>
/// <returns>Ссылка ветви</returns>
public SortNode Put(SortNode node)
{
if (node.Value.CompareTo(Value) < 0)
{
return(node.Put(this));
}
else if (lcount <= rcount)
{
left = (left == null) ? node : left.Put(node); lcount = left.Count;
}
else
{
right = (right == null) ? node : right.Put(node); rcount = right.Count;
}
return(this);
}
private static SortNode Split(IEnumerable <T> elements, T mediumElement)
{
var sortNode = new SortNode();
foreach (var element in elements)
{
if (element.CompareTo(mediumElement) < 0)
{
sortNode.SmallerValues.Add(element);
}
else
{
sortNode.GreaterValues.Add(element);
}
}
return(sortNode);
}
public void Successfully_SortAscendingWithNestedMath()
{
var data = Data(SortConf);
var inner1 = new MathNode(MathOp.Add, Three, Two);
var inner2 = new MathNode(MathOp.Add, Five, Four);
var sub = new MathNode(MathOp.Subtract, inner1, inner2);
var inner3 = new MathNode(MathOp.Multiply, Six, One);
var add = new MathNode(MathOp.Add, sub, inner3);
var group = new GroupNode(null, new List <DiceAST> {
add
});
var func = new FunctionNode(FunctionScope.Group, "expand", new DiceAST[0], data);
func.Context.Expression = group;
var node = new SortNode(SortDirection.Ascending)
{
Expression = func
};
EvaluateNode(node, data, 0, "{3 + 2 - (5 + 4) + 6 * 1}.expand().sortAsc() => (2 + 3 - (4 + 5) + 1 * 6) => 2");
}
public static IEnumerable <T> FindPath(T start, T end, Heuristic heuristic)
{
HashSet <T> visited = new HashSet <T>();
List <SortNode> open = new List <SortNode>();
Dictionary <T, T> cameFrom = new Dictionary <T, T>();
Stack <T> path = new Stack <T>();
open.Add(new SortNode()
{
Node = start
});
while (open.Count > 0)
{
open.Sort();
SortNode current = open[0];
if (current.Node.IsMatch(end))
{
T pathNode = current.Node;
path.Push(pathNode);
while (cameFrom.ContainsKey(pathNode))
{
pathNode = cameFrom[pathNode];
path.Push(pathNode);
}
break;
}
open.RemoveAt(0);
foreach (T neighbor in current.Node.GetNeighbors())
{
if (visited.Contains(neighbor))
{
continue;
}
// Calculate GScore by current node's accumulated cost plus the neighbor's
// entrance edge cost
int tentativeGScore = current.GScore + current.Node.GetEdgeCost(neighbor);
// If the recorded distance is less than the neighbor distance, replace it
SortNode oldNeighbor = open.Find(node => node.Node.Equals(neighbor));
if (oldNeighbor == null)
{
oldNeighbor = new SortNode()
{
Node = neighbor,
GScore = Int32.MaxValue
};
open.Add(oldNeighbor);
}
if (tentativeGScore < oldNeighbor.GScore)
{
oldNeighbor.GScore = tentativeGScore;
oldNeighbor.FScore = tentativeGScore + heuristic(oldNeighbor.Node, end);
cameFrom[oldNeighbor.Node] = current.Node;
}
}
visited.Add(current.Node);
}
return(path);
}
