SortItem AddSortItem(SortOrder s)
{
var si = new SortItem(s);
SortMenuItem.DropDownItems.Add(si);
return(si);
}
/// <summary>
/// Check if item may be placed into this cell.
/// </summary>
/// <returns><c>true</c> if this instance is sort allowed the specified item; otherwise, <c>false</c>.</returns>
/// <param name="item">Item.</param>
public bool IsSortAllowed(GameObject item)
{
bool res = false;
if (item != null)
{
SortItem sortItem = item.GetComponent <SortItem>();
if (allowedItemTypes.Count <= 0)
{
res = true;
}
else
{
if (sortItem != null)
{
foreach (string itemType in allowedItemTypes)
{
// If item has allowed sort
if (itemType == sortItem.itemType)
{
res = true;
break;
}
}
}
}
}
return(res);
}
public void Sort_MultipleElementsTwoDependencyDeep_CanSortByDependency()
{
// Arrange
var a = new SortItem("A");
var c = new SortItem("C");
var f = new SortItem("F");
var h = new SortItem("H");
var d = new SortItem("D");
var g = new SortItem("G");
var e = new SortItem("E");
var b = new SortItem("B");
d.SetDependencies(a);
g.SetDependencies(f, h);
e.SetDependencies(d, g);
b.SetDependencies(c, e);
var unsorted = new[] { a, b, c, d, e, f, g, h };
// Act
TopologicalSorter topologicalSorter = new TopologicalSorter();
var sorted = topologicalSorter.Sort(unsorted, x => x.Dependencies, new SortItemEqualityComparer());
// Assert
Assert.Equal(8, sorted.Count);
Assert.Equal("A", sorted[0].Name);
Assert.Equal("C", sorted[1].Name);
Assert.Equal("D", sorted[2].Name);
Assert.Equal("F", sorted[3].Name);
Assert.Equal("H", sorted[4].Name);
Assert.Equal("G", sorted[5].Name);
Assert.Equal("E", sorted[6].Name);
Assert.Equal("B", sorted[7].Name);
}
public override object getExtraInfo(SelectableMediaItem selectableItem)
{
String info = null;
ImageResultItem item = (ImageResultItem)selectableItem.Item;
SortItem sortItem = (SortItem)SortModes.CurrentItem;
switch (sortItem.SortMode)
{
case SortMode.Width:
case SortMode.Height:
info = item.ImageInfo.Width + " x " + item.ImageInfo.Height;
break;
case SortMode.Size:
info = MiscUtils.formatSizeBytes(item.ImageInfo.FileSize.Value);
break;
case SortMode.MimeType:
info = item.ImageInfo.ContentType;
break;
case SortMode.Location:
info = item.ImageInfo.SourceUrl;
break;
default:
break;
}
return(info);
}
public SortWrapper(SortItem handler)
{
if (handler == null)
{
throw new ArgumentNullException("handler");
}
_sorter = handler;
}
// Sort the eigenvalues and compute the corresponding permutation of the
// indices of the array storing the eigenvalues. The permutation is used
// for reordering the eigenvalues and eigenvectors in the calls to
// GetEigenvalues(...) and GetEigenvectors(...).
private void ComputePermutation(int sortType)
{
mIsRotation = -1;
if (sortType == 0)
{
// Set a flag for GetEigenvalues() and GetEigenvectors() to know
// that sorted output was not requested.
mPermutation[0] = -1;
return;
}
// Compute the permutation induced by sorting. Initially, we start with
// the identity permutation I = (0,1,...,N-1).
var items = new SortItem[mSize];
for (int i = 0; i < mSize; ++i)
{
items[i].eigenvalue = mDiagonal[i];
items[i].index = i;
}
if (sortType > 0)
{
//std::sort(items.begin(), items.end(), std::less<SortItem>());
Array.Sort(items, (a, b) => { return(a.eigenvalue == b.eigenvalue ? 0 : a.eigenvalue < b.eigenvalue ? -1 : 1); });
}
else
{
//std::sort(items.begin(), items.end(), std::greater<SortItem>());
Array.Sort(items, (a, b) => { return(a.eigenvalue == b.eigenvalue ? 0 : a.eigenvalue > b.eigenvalue ? -1 : 1); });
}
for (int i = 0; i < mSize; ++i)
{
mPermutation[i] = items[i].index;
}
//typename std::vector < SortItem >::const_iterator item = items.begin();
//for (i = 0; item != items.end(); ++item, ++i) {
// mPermutation[i] = item->index;
//}
// GetEigenvectors() has nontrivial code for computing the orthogonal Q
// from the reflections and rotations. To avoid complicating the code
// further when sorting is requested, Q is computed as in the unsorted
// case. We then need to swap columns of Q to be consistent with the
// sorting of the eigenvalues. To minimize copying due to column swaps,
// we use permutation P. The minimum number of transpositions to obtain
// P from I is N minus the number of cycles of P. Each cycle is reordered
// with a minimum number of transpositions; that is, the eigenitems are
// cyclically swapped, leading to a minimum amount of copying. For
// example, if there is a cycle i0 -> i1 -> i2 -> i3, then the copying is
// save = eigenitem[i0];
// eigenitem[i1] = eigenitem[i2];
// eigenitem[i2] = eigenitem[i3];
// eigenitem[i3] = save;
}
private SortItem ConvertRequestSort(string sort)
{
string[] sortItem = sort.Split('|');
SortItem item = new SortItem();
item.FieldName = sortItem[0];
item.IsDescending = bool.Parse(sortItem[1]);
return(item);
}
public IActionResult Submit([FromBody] SortItem item)
{
if (item == null)
{
return(HttpBadRequest());
}
sortArray.sort(item);
return(new ObjectResult(item));
}
public int CompareTo(object obj)
{
SortItem item = obj as SortItem;
if (item == null || item.rate < rate)
{
return(-1);
}
return(1);
}
public SearchResult Search(string index, string type, IQuery query, SortItem sortItem, int from = 0, int size = 5, string[] fields = null)
{
string[] temp = null;
if (type != null)
{
temp = new[] { type }
}
;
return(Search(index, temp, query, sortItem, from, size, fields));
}
void sortItems_ItemSortDirectionChanged(object sender, EventArgs e)
{
SortItem sortItem = (SortItem)sender;
if (((SortItem)SortModes.CurrentItem).SortMode == sortItem.SortMode)
{
SortDirection = sortItem.SortDirection;
refresh();
}
}
/// <summary>
/// Gets the sort item from this cell.
/// </summary>
/// <returns>The sort item.</returns>
public SortItem GetSortItem()
{
SortItem res = null;
GameObject item = GetComponent <DadCell>().GetItem();
if (item != null)
{
res = item.GetComponent <SortItem>();
}
return(res);
}
void Awake()
{
for (int i = 0; i < title.Length; i++)
{
GameObject instance = GameObject.Instantiate(singleLetter, transform);
instance.GetComponent <Text>().text = title[i].ToString();
SortItem sortItem = instance.GetComponent <SortItem>();
sortItem.size = i;
sortItems.Add(sortItem);
}
}
private void ContentDialog_PrimaryButtonClick(ContentDialog sender, ContentDialogButtonClickEventArgs args)
{
StringBuilder builder = new StringBuilder();
foreach (var item in list.Items)
{
SortItem sortItem = item as SortItem;
builder.Append($"{sortItem.Title}_{sortItem.Tid}.");
}
SettingHelper.SetValue("_sort", builder.Remove(builder.Length - 1, 1).ToString());
action();
}
public static MethodInfo GetOrderByMethod(SortItem sortItem)
{
var methodName = sortItem.SortDirection == ListSortDirection.Ascending ? "OrderBy" : "OrderByDescending";
var orderByMethodInfo = typeof(Queryable)
.GetMethods(BindingFlags.Public | BindingFlags.Static)
.Single(mi => mi.Name == methodName &&
mi.IsGenericMethodDefinition &&
mi.GetGenericArguments().Length == 2 &&
mi.GetParameters().Length == 2);
return(orderByMethodInfo);
}
int FindCurrentPosition(List <SortItem> currList, SortItem si)
{
for (int i = 0; i < currList.Count; i++)
{
if (currList[i].ord > si.ord)
{
return(i);
}
}
return(-1);
}
private void AggregateBatches(RawList <SortItem> sortItems, RawList <VertexDrawItem> drawItems, RawList <DrawBatch> batches)
{
VertexDrawItem[] drawData = drawItems.Data;
SortItem[] sortData = sortItems.Data;
SortItem activeSortItem = sortData[0];
VertexDrawItem activeItem = drawData[activeSortItem.DrawItemIndex];
int beginBatchIndex = 0;
// Find sequences of draw items that can be batched together
int count = sortItems.Count;
for (int sortIndex = 1; sortIndex <= count; sortIndex++)
{
// Skip items until we can no longer put the next one into the same batch
if (sortIndex < count)
{
SortItem sortItem = sortData[sortIndex];
if (activeItem.CanShareBatchWith(ref drawData[sortItem.DrawItemIndex]))
{
continue;
}
}
// Create a batch for all previous items
VertexBuffer vertexBuffer = this.vertexBuffers[activeItem.TypeIndex][activeItem.BufferIndex];
DrawBatch batch = new DrawBatch(
vertexBuffer,
this.batchIndexPool.Rent(sortIndex - beginBatchIndex),
activeItem.Mode,
activeItem.Material);
for (int i = beginBatchIndex; i < sortIndex; i++)
{
batch.VertexRanges.Add(new VertexDrawRange
{
Index = drawData[sortData[i].DrawItemIndex].Offset,
Count = drawData[sortData[i].DrawItemIndex].Count
});
}
batches.Add(batch);
// Proceed with the current item being the new sharing reference
if (sortIndex < count)
{
beginBatchIndex = sortIndex;
activeSortItem = sortData[sortIndex];
activeItem = drawData[activeSortItem.DrawItemIndex];
}
}
}
private static IEnumerable <Lazy <T, IOrderMetadata> > Order(IEnumerable <Lazy <T, IOrderMetadata> > collection)
{
IndexDictionary index = new IndexDictionary(collection);
SortItem root = new SortItem();
foreach (Lazy <T, IOrderMetadata> item in collection)
{
SortItem sourceItem = null;
if (!String.IsNullOrEmpty(item.Metadata.ID) && index.ContainsKey(item.Metadata.ID))
{
sourceItem = index[item.Metadata.ID];
}
else
{
sourceItem = new SortItem();
sourceItem.Item = item;
}
if (!string.IsNullOrEmpty(item.Metadata.Before) && index.ContainsKey(item.Metadata.Before))
{
SortItem targetItem = index[item.Metadata.Before];
if (!targetItem.Used)
{
sourceItem.Children.Add(targetItem);
targetItem.Used = true;
}
}
else
if (!string.IsNullOrEmpty(item.Metadata.After) && index.ContainsKey(item.Metadata.After))
{
if (!sourceItem.Used)
{
SortItem targetItem = index[item.Metadata.After];
targetItem.Children.Add(sourceItem);
sourceItem.Used = true;
}
}
if (!sourceItem.Used)
{
root.Children.Add(sourceItem);
sourceItem.Used = true;
}
}
return(root.ToCollection());
}
public StatementBuilder Pipeline()
{
StatementBuilder statement = Cypher.Match(Node).Return(Node);
if (_filters is not null)
{
statement.Match(new Where(_filters), Node);
}
if (_projection is not null)
{
statement.Return(Node.Project(_projection));
}
if (_sorting is null)
{
return(statement);
}
var sorts = new List <SortItem>();
foreach (Neo4JSortDefinition sort in _sorting)
{
SortItem sortItem = Cypher.Sort(Node.Property(sort.Field));
if (sort.Direction == SortDirection.Ascending)
{
sorts.Push(sortItem.Ascending());
}
else if (sort.Direction == SortDirection.Descending)
{
sorts.Push(sortItem.Descending());
}
}
statement.OrderBy(sorts);
if (_limit is not null)
{
statement.Limit((int)_limit);
}
if (_skip is not null)
{
statement.Limit((int)_skip);
}
return(statement);
}
public void Sort_FirstOrderCircularDependency_ThrowsSortException()
{
// Arrange
var a = new SortItem("A");
var c = new SortItem("C");
a.SetDependencies(c);
c.SetDependencies(a);
var unsorted = new[] { a, c };
// Act and Assert
TopologicalSorter topologicalSorter = new TopologicalSorter();
CircularDependencyException<SortItem> exception = Assert.Throws<CircularDependencyException<SortItem>>(
() => topologicalSorter.Sort(unsorted, x => x.Dependencies, new SortItemEqualityComparer()));
Assert.Equal(1, exception.AffectedItems.Count);
Assert.Equal("A", exception.AffectedItems[0].Name);
}
public void Sort(Span <SeqNo> input, Span <SortItem> outputItems)
{
if (input.Length != outputItems.Length)
{
throw new InvalidOperationException();
}
for (var i = 0; i < outputItems.Length; i++)
{
outputItems[i] = new SortItem(i, GetDifference(input[i].Value, Value));
}
#warning TODO: SeqNo.Sort
//public bool LessThan(SortItem a, SortItem b)
//{
// return a.Value < b.Value;
//}
// TODO: outputItems.WithOrder(new Ordering()).Sort();
}
public void Populate(List <Tuple <string, string, int> > fields)
{
//foreach (var s in fields)
//{
// this.availibleFields.Add(s);
//}
for (int i = 0; i < fields.Count; i++)
{
var si = new SortItem()
{
val = fields[i].Item1, disp = fields[i].Item2, ord = fields[i].Item3
};
availibleFields.Add(si);
}
lstAvailFlds.DataSource = availibleFields;
lstAvailFlds.DisplayMember = "disp";
lstAvailFlds.ValueMember = "val";
lstSortFlds.DataSource = sortedFields;
}
public SearchResult Search(string index, string[] type, IQuery query, SortItem sortItem, int from, int size, string[] fields = null)
{
Contract.Assert(!string.IsNullOrEmpty(index));
Contract.Assert(query != null);
Contract.Assert(from >= 0);
Contract.Assert(size > 0);
var elasticQuery = new ElasticQuery(from, size);
elasticQuery.SetQuery(query);
if (sortItem != null)
{
elasticQuery.AddSortItem(sortItem);
}
if (fields != null)
{
elasticQuery.AddFields(fields);
}
return(Search(index, type, elasticQuery));
}
public JsonResult Sort([FromBody] SortItem sortItem)
{
string[] splitValues = sortItem.InputValue.Split(',');
int[] intValues;
if (sortItem.InputValue.Equals("") ||
splitValues.Length == 0 ||
splitValues.Length > 500)
{
return(Json(new { success = false, error = "Input size is 1 to 500 values." }));
}
switch (sortItem.InputTypeValue)
{
case "int":
if (!ValidateNumbers(splitValues))
{
return(Json(new { success = false, error = "Invalid Numbers(not integer size)" }));
}
intValues = Array.ConvertAll(splitValues, (string value) =>
{
return(int.Parse(value));
});
return(Json(new { success = true, data = InsertionSort.SortIntArray(intValues) }));
case "string":
if (!ValidateStrings(splitValues))
{
return(Json(new { success = false, error = "String values are up to 10 characters long." }));
}
return(Json(new { success = true, data = InsertionSort.SortStringArray(splitValues) }));
default:
return(Json(new { success = false, error = "Invalid input type." }));
}
}
IEnumerator fullSort()
{
yield return(new WaitForSeconds(time));
for (int j = sortItems.Count - 1; j > 0; j--)
{
for (int i = 0; i < j; i++)
{
if (sortItems[i].size > sortItems[i + 1].size)
{
SortItem temp = sortItems[i];
sortItems[i] = sortItems[i + 1];
sortItems[i + 1] = temp;
//Animation Stuff
sortItems[i].move(indexToLetterPos(i), time, 0, 40);
sortItems[i + 1].move(indexToLetterPos(i + 1), time, 0, -40);
yield return(new WaitForSeconds(time));
}
}
}
}
private static int DepthSortComparison(SortItem first, SortItem second)
{
if (second.SortDepth < first.SortDepth)
{
return(-1);
}
if (second.SortDepth > first.SortDepth)
{
return(1);
}
if (second.SortDepth == first.SortDepth)
{
return(0);
}
if (float.IsNaN(second.SortDepth))
{
return(float.IsNaN(first.SortDepth) ? 0 : -1);
}
else
{
return(1);
}
}
//Generated the query clause
private void GenerateClause()
{
try
{
string cl = "";
//Clear all existing items, they will be regenerated
SortedItems.Clear();
foreach (string s in TheSorts)
{
for (int i = 0; i < taig.Rows; i++)
{
if (taig.get_item(i, 0) == s)
{
cl += s + " " + taig.get_item(i, 2) + ",";
SortItem si = new SortItem(s, taig.get_item(i, 2));
SortedItems.Add(si);
break;
}
}
}
if (cl != "")
{
cl = "ORDER BY " + cl.Substring(0, cl.Length - 1);
}
txtClause.Text = cl;
Clause = cl;
}
catch (Exception ex)
{
showError("Unable to generate the query clause" + System.Environment.NewLine
+ ex.Message);
}
}
//populates an existing sort item's data
private void populateData(string[] meta)
{
try
{
ArrayList rowIDs = new ArrayList();
//populate SortedItems list
for (int i = 0; i < meta.Length; i++)
{
string[] sortedField = meta[i].Split(',');
SortItem si = new SortItem(sortedField[0], sortedField[1]);
SortedItems.Add(si);
}
foreach (SortItem s in SortedItems)
{
//select the row in the grid & set the sort properties
int rowID = taig.FindInColumn(s.SortField, taig.GetColumnIDByName("FIELD"), false);
if (rowID != -1)
{
taig.set_item(rowID, taig.GetColumnIDByName("SORT"), "YES");
taig.set_item(rowID, taig.GetColumnIDByName("DIRECTION"), s.SortDirection);
rowIDs.Add(rowID);
TheSorts.Add(s.SortField);
}
}
//highlight all selected fields
taig.SelectRows(rowIDs);
}
catch (Exception ex)
{
showError("Unable to load the sort item's data" + System.Environment.NewLine
+ ex.Message);
}
}
public GenericQuery(IFilter <T> filters, SortItem <T> sortItem) : this(filters, sortItem, null)
{
}
public GenericQuery(IFilter <T> filters, SortItem <T> sortItem, string orderQuery)
{
this.Filters = filters;
this.SortItem = sortItem;
this.SortQuery = orderQuery;
}
public void Sort_TwoElementsOneDependencyDeep_CanSortByDependency()
{
// Arrange
SortItem a = new SortItem("A");
SortItem c = new SortItem("C");
c.SetDependencies(a);
SortItem[] unsorted = new[] { c, a };
// Act
TopologicalSorter topologicalSorter = new TopologicalSorter();
IList<SortItem> sorted = topologicalSorter.Sort(unsorted, x => x.Dependencies, new SortItemEqualityComparer());
// Assert
Assert.Equal(2, sorted.Count);
Assert.Equal("A", sorted[0].Name);
Assert.Equal("C", sorted[1].Name);
}
public static DsDevice[] Sort(DsDevice[] devices, params object[] arg)
{
try
{
if (devices == null)
return devices;
if (devices.Length <= 1)
return devices;
List<string> compareNames = new List<string>();
foreach (object obj in arg)
{
String name = obj as String;
if (!string.IsNullOrEmpty(name))
{
compareNames.Add(name);
continue;
}
DsDevice dev = obj as DsDevice;
if (dev == null)
continue;
if (dev.Name == null)
continue;
if (dev.Name.Length == 0)
continue;
compareNames.Add(dev.Name);
}
if (compareNames.Count == 0)
return devices;
List<string> names = new List<string>();
for (int i = 0; i < devices.Length; ++i)
{
if (devices[i] == null)
continue;
if (devices[i].Name == null)
continue;
if (devices[i].Name.Length == 0)
continue;
names.Add(devices[i].Name);
}
//sort the devices based
float[] results = new float[devices.Length + 20];
for (int x = 0; x < results.Length; ++x)
{
results[x] = 0.0f;
}
for (int i = 0; i < compareNames.Count; ++i)
{
Levenstein comparer = new Levenstein();
float[] tmpResults = comparer.batchCompareSet(names.ToArray(), compareNames[i]);
for (int x = 0; x < tmpResults.Length; ++x)
{
results[x] += tmpResults[x];
}
}
List<SortItem> items = new List<SortItem>();
for (int i = 0; i < devices.Length; ++i)
{
SortItem item = new SortItem();
item.rate = results[i];
item.device = devices[i];
items.Add(item);
}
items.Sort();
DsDevice[] newDevices = new DsDevice[items.Count];
int index = 0;
foreach (SortItem item in items)
{
newDevices[index] = item.device;
index++;
}
return newDevices;
}
catch (Exception ex)
{
Log.Log.Write(ex);
return devices;
}
}
public IQueryable <Product> DynamicFieldSelectWithSortOption(FilterItem[] filterItems, SortItem sortItem)
{
var products = DynamicFieldSelection(filterItems);
return(GetOrderedList(products, sortItem));
}
private IOrderedQueryable <Product> GetOrderedList(IQueryable <Product> products, SortItem sortItem)
{
ParameterExpression p = _expressionBuilder.BuildParameterExpression <Product>("product");
MethodInfo orderBy = DemoHelper.GetOrderByMethod(sortItem);
MemberExpression sortMember = Expression.PropertyOrField(p, sortItem.SortField);
Expression sortExpression = Expression.Lambda(sortMember, p);
Type sortByPropType = typeof(Product).GetProperty(sortItem.SortField).PropertyType;
var sortedList = (orderBy.MakeGenericMethod(new[] { typeof(Product), sortByPropType })
.Invoke(products, new object[] { products, sortExpression }) as IOrderedQueryable <Product>);
return(sortedList);
}
