void RenderLoop(int stagedLayer, SortingType sortType, bool clear, bool useGroupColor, Color overrideColor)
{
if (!useGroupColor)
{
Shader.SetGlobalColor(_Color, overrideColor);
}
bool clearedCamera = false;
for (int i = 0; i < highlightGroups.Count; i++)
{
HighlightGroup group = highlightGroups[i];
if (group.sortingType == sortType)
{
TempCam.clearFlags = clearedCamera || !clear ? CameraClearFlags.Nothing : CameraClearFlags.Color;
// if (clear) {
// }
clearedCamera = true;
if (useGroupColor)
{
Shader.SetGlobalColor(_Color, group.highlightColor);
}
group.Stage(stagedLayer);
TempCam.RenderWithShader(DrawSimple, "");
group.Unstage();
}
}
}
private IOrderedQueryable <T> AddOrderBy <T>(IQueryable <T> source, SortingType type, MemberExpression expression, ParameterExpression parameter) where T : class
{
var command = default(string);
switch (type)
{
case SortingType.OrderBy:
command = nameof(Queryable.OrderBy);
break;
case SortingType.OrderThenBy:
command = nameof(Queryable.ThenBy);
break;
case SortingType.OrderByDescending:
command = nameof(Queryable.OrderByDescending);
break;
case SortingType.OrderThenByDescending:
command = nameof(Queryable.ThenByDescending);
break;
default:
throw new NotSupportedException();
}
var orderByExpression = Expression.Lambda(expression, parameter);
var typeArguments = new Type[] { typeof(T), expression.Type };
var resultExpression = Expression.Call(typeof(Queryable), command, typeArguments, source.Expression, Expression.Quote(orderByExpression));
return(source.Provider.CreateQuery <T>(resultExpression) as IOrderedQueryable <T>);
}
public void LoadEntriesFromList(SortingType sortingType)
{
if (sortingType == SortingType.SortByWinrate)
{
entryList = entryList.OrderByDescending(x => double.Parse(x[1])).ToList();
}
else
{
entryList = entryList.OrderByDescending(x => double.Parse(x[2])).ToList();
}
foreach (Transform child in scoreList.transform)
{
Destroy(child.gameObject);
}
foreach (string[] entry in entryList)
{
GameObject entryObject = Instantiate(scoreEntryPrefab, scoreList.transform);
entryObject.transform.Find("Name").GetComponent <Text>().text = entry[0];
entryObject.transform.Find("Winrate").GetComponent <Text>().text = (double.Parse(entry[1]) * 100).ToString("0.000") + "%";
entryObject.transform.Find("Accuracy").GetComponent <Text>().text = (double.Parse(entry[2]) * 100).ToString("0.000") + "%";
}
}
public IEnumerable <ReportRecord> SortCalls(Report report, SortingType sortType)
{
var rep = report.GetRecords();
switch (sortType)
{
case SortingType.ByCallType:
return(rep.
OrderBy(x => x.CallType).
ToList());
case SortingType.ByDateOfCall:
return(rep.
OrderBy(x => x.Date).
ToList());
case SortingType.ByCost:
return(rep
.OrderBy(x => x.Cost)
.ToList());
case SortingType.ByNumber:
return(rep.
OrderBy(x => x.Number).
ToList());
default:
return(rep);
}
}
public List <AdInfo> SortAllEntriesInList(SortingType type)
{
List <AdInfo> sorted = new List <AdInfo>();
switch (type)
{
case SortingType.AdvertizeDescription:
sorted = CurrentOperating.OrderBy(sort => sort.AdvertizeDescription).ToList();
break;
case SortingType.PersonName:
sorted = CurrentOperating.OrderBy(sort => sort.Person.Name).ToList();
break;
case SortingType.PersonSurname:
sorted = CurrentOperating.OrderBy(sort => sort.Person.Surname).ToList();
break;
case SortingType.PhoneNumber:
sorted = CurrentOperating.OrderBy(sort => sort.PhoneNumber).ToList();
break;
case SortingType.Price:
sorted = CurrentOperating.OrderBy(sort => sort.Price).ToList();
break;
default:
break;
}
return(sorted);
}
public static CodeExplorerSortingClass <T> GetInstance(SortingType type)
{
var inst = Instance;
inst.Type = type;
return(inst);
}
private void refreshButton_Click(object sender, EventArgs e)
{
dataGridView1.Rows.Clear();
RoutesFinder finder = new RoutesFinder();
SortingType sortingType = SortingType.ByTotalProfit;
if (profitPerIsk.Checked)
{
sortingType = SortingType.ByProfitPerIsk;
}
if (profitPerUnit.Checked)
{
sortingType = SortingType.ByProfitPerUnit;
}
if (profitPerVolume.Checked)
{
sortingType = SortingType.ByProfitPerVolume;
}
loadedRoutes = finder.GetRoutes(sortingType);
LoadRoutes(loadedRoutes);
}
public void Execute()
{
SortingType sortingType = GetSortingType();
if (sortingType == SortingType.Exit)
{
return;
}
ISortingAlgorithm algorithm = GetSortingAlgorithm(sortingType);
Console.WriteLine("What's the input file name?");
string inputFilename = Console.ReadLine();
string[] linesIn = File.ReadAllLines(inputFilename);
Console.WriteLine("What's the output file name?");
string outputFilename = Console.ReadLine();
Stopwatch stopWatch = new Stopwatch();
string[] linesOut;
Console.WriteLine("Sorting...");
double[] items = linesIn.Select(line => double.Parse(line)).ToArray();
stopWatch.Start();
algorithm.Sort(items);
stopWatch.Stop();
linesOut = items.Select(item => item.ToString()).ToArray();
File.WriteAllLines(outputFilename, linesOut);
ProgramUtils.WriteLineImpressive($"Succesfully sorted the values in {inputFilename} and wrote the result to {outputFilename} in {stopWatch.ElapsedMilliseconds} ms");
}
private IQueryable <Advert> Sort(IQueryable <Advert> query, SortingType sortingType)
{
switch (sortingType)
{
case SortingType.ByPriceAsc:
query = query.OrderBy(ad => ad.Price);
break;
case SortingType.ByPriceDesc:
query = query.OrderByDescending(ad => ad.Price);
break;
case SortingType.ByPublishDateAsc:
query = query.OrderBy(ad => ad.CreatedDate);
break;
case SortingType.ByPublishDateDesc:
query = query.OrderByDescending(ad => ad.CreatedDate);
break;
default:
break;
}
return(query);
}
/// <summary>Sorts contact list by zip.</summary>
/// <param name="listContacts">The list contacts.</param>
public static void SortByZip(List <AddressBookModel> listContacts)
{
sortType = SortingType.SORT_BY_ZIP;
listContacts.Sort(delegate(AddressBookModel x, AddressBookModel y)
{
return((x.Zip).CompareTo((y.Zip)));
});
}
/// <summary>Sorts contact list by State.</summary>
/// <param name="listContacts">The list contacts.</param>
public static void SortByState(List <AddressBookModel> listContacts)
{
sortType = SortingType.SORT_BY_STATE;
listContacts.Sort(delegate(AddressBookModel x, AddressBookModel y)
{
return((x.State.ToLower()).CompareTo((y.State.ToLower())));
});
}
public static void AddHighlightGroup(Color color, SortingType sortingType)
{
if (instance == null)
{
return;
}
instance.highlightGroups.Add(new HighlightGroup(color, sortingType));
}
/// <summary>Sorts contact list by name.</summary>
/// <param name="listContacts">The list contacts.</param>
public static void SortByName(List <AddressBookModel> listContacts)
{
sortType = SortingType.SORT_BY_NAME;
listContacts.Sort(delegate(AddressBookModel x, AddressBookModel y)
{
return((x.FirstName.ToLower() + x.LastName.ToLower()).CompareTo((y.FirstName.ToLower() + y.LastName.ToLower())));
});
}
private void ChangeSorting(SortingType _arg)
{
m_ButtonsMoving = false;
StopAllCoroutines();
m_Sorting = _arg;
if (m_Sorting == SortingType.None)
{
EnableVerticalTriggers(false);
}
}
public void AddRenderers(List <Renderer> renderers, Color col, SortingType sorting)
{
var data = new OutlineData()
{
color = col, sortingType = sorting
};
m_objectRenderers.Add(renderers, data);
RecreateCommandBuffer();
}
public List <Route> GetRoutes(SortingType sorting)
{
routes.Clear();
foreach (var pair in Program.dataBase.items)
{
AnalyzeItem(pair.Key, sorting);
}
return(routes.Values.ToList());
}
/// <summary>
/// Sorts the inventory
/// </summary>
/// <param name="sorting">How to sort the inventory</param>
public static void SortInventory(SortingType sorting)
{
if (sorting == SortingType.AmountDecreasing)
{
itemList.Sort((x, y) => x.CompareTo(y));
}
else
{
itemList.Sort((x, y) => y.CompareTo(x));
}
}
private byte[,] removeNoiseRun(int windowSize, int trimValue, SortingType sortingType)
{
int windowStep = (windowSize - 1) / 2;
int imageHeight = imageMatrix.GetLength(0);
int imageWidth = imageMatrix.GetLength(1);
byte[] window = new byte[windowSize * windowSize];
for (int i = windowStep; i < imageHeight - windowStep; i++)
{
for (int j = windowStep; j < imageWidth - windowStep; j++)
{
/* Iterations happening for every pixel in the image */
for (int m = 0, n = i - windowStep; m < windowSize; m++, n++)
{
for (int k = 0, l = j - windowStep; k < windowSize; k++, l++)
{
window[m + (windowSize * k)] = imageMatrix[n, l]; //Making a window
}
}
//byte[] newWindow = ImageTools.to1D(window); //Convert to 1D. EDIT: NOT NEEDED NOW.
byte[] newWindow = window;
if (sortingType == SortingType.BUILT_IN_SORT) //Sort
{
Array.Sort(newWindow);
}
else if (sortingType == SortingType.KTH_ELEMENT)
{
newWindow = Sort.KthElement.sort(ref newWindow, trimValue);
}
else if (sortingType == SortingType.COUNTING_SORT)
{
newWindow = Sort.CountingSort.sort(newWindow);
}
else if (sortingType == SortingType.QUICK_SORT)
{
int right = newWindow.Length - 1;
Sort.quicksort.QuickSort_Recursive(newWindow, 0, right);
}
newWindow = ImageTools.exclude(newWindow, trimValue); //Exclude by trim (T)
byte avg = ImageTools.arrAverage(newWindow); //Claculate average
//btnOpen.Text = avg.ToString(); //FOR TESTING ONLY. PERFORMANCE KILLER!
imageMatrix[i, j] = avg; //Setting the damn value.
//pictureBox.Update(); //Updating the show. NOT necessary, but showy.
}
}
return(imageMatrix);
}
public static List <PlayerStat> SortScoreBoard(List <PlayerStat> scoreBoard, SortingType filter)
{
if (scoreBoard == null)
{
return(null);
}
var sortedBoard = scoreBoard.ToArray();
Array.Sort(sortedBoard, (a, b) => (-1 + (int)filter) * (a.Score.CompareTo(b.Score)));
return(sortedBoard.ToList());
}
async Task <List <Todo> > ITodosService.GetTodos(string todoType, SortingType sortingType)
{
TodoCategory todoCategory = _todoRepository.FindCategoryByName(todoType);
if (todoCategory == null)
{
var ex = new CategoryNotFoundException(404, "Nem található ilyen kategória: " + todoType);
_logger.LogError($"Nem található ilyen kategória : {todoType}");
throw ex;
}
return(await _todoRepository.GetTodos(todoCategory, sortingType));
}
/// <summary>
/// Change the sorting order
/// </summary>
/// <param name="sortingType"></param>
internal void ChangeSorting(SortingType sortingType)
{
if (Collection == null)
{
return;
}
using (Collection.DeferRefresh())
{
Collection.SortDescriptions.Clear();
Collection.SortDescriptions.Add(new SortDescription(sortingType.ToString(), ListSortDirection.Ascending));
}
}
protected ISortingAlgorithm GetSortingAlgorithm(SortingType type)
{
switch (type)
{
case SortingType.SelectionSort: return(new SelectionSort());
case SortingType.QuickSort: return(new QuickSort());
case SortingType.MergeSort: return(new MergeSort());
default: throw new NotSupportedException();
}
}
public PartialViewResult Menu(string category, SortingType sortingOption = 0)
{
ViewBag.SelectedCategory = category;
ViewBag.SelectedSortingOption = sortingOption;
var menuViewModel = new MenuViewModel
{
Categories = _categoryRepository.Categories,
SortingOptions = Enum.GetValues(typeof(SortingType)).Cast <SortingType>()
};
return(PartialView("FlexMenu", menuViewModel));
}
private FiltersWithSorting GetFiltersWithSortingFromJson(JObject json)
{
var sorting = json["sorting"].ToString();
var name = json["name"].ToString();
var gameDates = json["gameDates"].ToString();
var remainingShips = json["remainingShips"].ToString() == "" ? -1 : json["remainingShips"].ToObject <int>();
var gameTurns = json["gameTurns"].ToString() == "" ? -1 : json["gameTurns"].ToObject <int>();
var sortingItemElements = sorting.Split('/');
var datesItems = gameDates.Split(" - ");
SortingDirection sortingDirection = sortingItemElements[0] switch
{
"desc" => SortingDirection.Descending,
"asc" => SortingDirection.Ascending
};
SortingType sortingType = sortingItemElements[1] switch
{
"ship" => SortingType.RemainingShipsSorting,
"date" => SortingType.DateSorting
};
DateTime firstDate;
DateTime secondDate;
List <IFilter> filters = new List <IFilter>();
if (DateTime.TryParse(datesItems[0], out firstDate) && DateTime.TryParse(datesItems[1], out secondDate))
{
filters.Add(new DateFilter(firstDate, secondDate));
}
if (!string.IsNullOrEmpty(name))
{
filters.Add(new PlayerFilter(name));
}
if (remainingShips != -1)
{
filters.Add(new RemainingShipFilter(remainingShips));
}
if (gameTurns != -1)
{
filters.Add(new GameTurnFilter(gameTurns));
}
return(new FiltersWithSorting()
{
Filters = filters,
Sorting = new SortingItem(sortingType, sortingDirection)
});
}
}
}
protected string GetTextForSortingType(SortingType choice)
{
switch (choice)
{
case SortingType.SelectionSort: return("Selection Sort");
case SortingType.QuickSort: return("Quicksort");
case SortingType.MergeSort: return("Mergesort");
case SortingType.Exit: return("Return to main menu");
default: return("Unkown choice");
}
}
public async Task <List <Todo> > GetTodos(SortingType sortingType = SortingType.TimeDESC)
{
var todos = await _context.Todos
.Include(todo => todo.Type)
.OrderByDescending(t => t.CreationDate)
.ToListAsync();
if (todos == null)
{
_logger.LogWarning(" Zero todo found!");
return(null);
}
_logger.LogDebug($"Got Todos sorting by : {sortingType}");
return(todos);
}
//---------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------
public void Filter(SortingType sortingType)
{
int x_init = WinMaxSiz / 2;
int y_init = WinMaxSiz / 2;
for (int X = 0; X < imageMatrix.GetLength(0); X++)
{
for (int Y = 0; Y < imageMatrix.GetLength(1); Y++)
{
SrchTruMedian(window(x_init + X, y_init + Y, initImage, WinSize, WinMaxSiz), WinSize, initImage, x_init + X, y_init + Y, sortingType);
imageMatrix[X, Y] = NewPixelVal;
}
}
}
public async Task <List <Todo> > GetDeletedTodos(SortingType sortingType = SortingType.TimeDESC)
{
var todos = await _context.Todos
.IgnoreQueryFilters()
.Where(t => t.Deleted == true)
.OrderByDescending(t => t.CreationDate)
.ToListAsync();
if (todos == null)
{
_logger.LogWarning("Zero todo found!");
return(null);
}
_logger.LogInformation($"Got deleted todos sorting by : {sortingType} ");
return(todos);
}
public void ShowSortedCallInfo(IReportRender render, Billing.BL.Classes.Billing billing, ITerminal terminal)
{
bool flag = true;
SortingType sortingType = SortingType.ByCost;
while (flag)
{
Console.WriteLine("Select the sort type:\n " +
"ByDateOfCall (enter {0}),\n " +
"ByCost (enter {1}),\n " +
"ByNumber (enter {2}),\n " +
"ByCallType (enter {3}),\n"
, 1, 2, 3, 4);
var key = Console.ReadKey().Key;
if (key == ConsoleKey.NumPad1 || key == ConsoleKey.D1)
{
flag = false;
sortingType = SortingType.ByDateOfCall;
}
else if (key == ConsoleKey.NumPad2 || key == ConsoleKey.D2)
{
flag = false;
sortingType = SortingType.ByCost;
}
else if (key == ConsoleKey.NumPad3 || key == ConsoleKey.D3)
{
flag = false;
sortingType = SortingType.ByNumber;
}
else if (key == ConsoleKey.NumPad4 || key == ConsoleKey.D4)
{
flag = false;
sortingType = SortingType.ByCallType;
}
else
{
Console.WriteLine();
}
}
foreach (var item in render.SortCalls(billing.GetReport(terminal.TelephonNumber), sortingType))
{
Console.WriteLine("\nCalls:\n Type {0} |\n Date: {1} |\n Duration: {2} | Cost: {3} | Telephone number: {4}",
item.CallType, item.Date, item.CallDuration.ToString("mm:ss"), item.Cost, item.Number);
}
}
public static string ToOpenIconicCssClassName(this SortingType type)
{
string cssName = "oi oi-";
switch (type)
{
case SortingType.Ascending:
cssName += "caret-top";
break;
case SortingType.Descending:
cssName += "caret-bottom";
break;
}
return(cssName);
}
private void ChangeSorting( SortingType _arg )
{
m_ButtonsMoving = false;
StopAllCoroutines();
m_Sorting = _arg;
if ( m_Sorting == SortingType.None ) {
EnableVerticalTriggers( false );
}
}
