/// <summary> /// Gets paged list of all VehicleModels. /// </summary> /// <param name="makeId"></param> /// <param name="filter"></param> /// <param name="paging"></param> /// <param name="sorting"></param> /// <returns> Paged list of all VehicleModels. </returns> public IPagedList<IVehicleModel> GetModels(Guid makeId, IFiltering filter, IPaging paging, ISorting sorting) { // Gets the search input. var searchString = filter.SearchString; // Gets the number and size of a page. int pageNumber = paging.PageNumber; int pageSize = paging.PageSize; // Gets the specific models of the make, conditioned by search string. var vehicleModels = genericRepository.GetSet<VehicleModel>().Where(m => m.MakeId == makeId); if (!String.IsNullOrEmpty(searchString)) { vehicleModels = vehicleModels.Where(m => m.Name == searchString || m.Abrev == searchString); } // Sorts the filtered list of models. var sortedModel = vehicleModels.OrderBy(sorting.Sorters.FirstOrDefault().GetSortExpression()); // Gets the paged list by parameters and maps it to corresponding type. var pagedList = genericRepository.GetPagedList(sortedModel, pageSize, pageNumber); IEnumerable<VehicleModelPoco> sourceList = Mapper.Map<IEnumerable<VehicleModel>, IEnumerable<VehicleModelPoco>>(pagedList); return new StaticPagedList<VehicleModelPoco>(sourceList, pagedList.GetMetaData()); }
/// <summary> /// Подсчитать время. затраченное на кол-во операций. /// </summary> /// <param name="sorting">Алгоритм сортировки.</param> /// <param name="data">Данные для сортировки.</param> /// <param name="operationCount">Кол-во операций для измерения времени.</param> /// <returns></returns> private static long getRunMilliseconds(ISorting sorting, int []data, int operationCount) { SortCore sortCore = new SortCore(sorting, null); System.Diagnostics.Stopwatch swatch = new System.Diagnostics.Stopwatch(); swatch.Start(); for (int i = 0; i <= operationCount; i++) { sortCore.process(data); } swatch.Stop(); return swatch.ElapsedMilliseconds; }
public IPagedList <IRental> GetAll(ISorting sorting, IFiltering filtering, IPaging paging, IOptions options) { IQueryable <IRental> rentals = _unitOfWork.GetAll <Rental>(); if (options.IncludeBooks) { rentals = rentals.Include(r => r.Book); } if (options.IncludeCustomers) { rentals = rentals.Include(r => r.Customer); } // filter records based on the DateReturned beeing null or not switch (filtering.RecordsFilter) { case "Rented": rentals = rentals.Where(r => r.DateReturned == null); break; case "Returned": rentals = rentals.Where(r => r.DateReturned != null); break; } if (!string.IsNullOrEmpty(filtering.SearchString)) { switch (filtering.SearchBy) { case "Book Title": rentals = rentals.Where(r => r.Book.Title.ToLower().Contains(filtering.SearchString.ToLower())); break; case "Customer Name": rentals = rentals.Where(r => r.Customer.LastName.ToLower().Contains(filtering.SearchString.ToLower()) || r.Customer.FirstName.ToLower().Contains(filtering.SearchString.ToLower())); break; case "Rental Id": rentals = rentals.Where(r => r.Id.ToString().Contains(filtering.SearchString)); break; } } switch (sorting.SortingParam) { case "dRented": rentals = rentals.OrderBy(c => c.DateRented); break; case "dReturned": rentals = rentals.OrderBy(c => c.DateRented); break; case "dReturned_desc": rentals = rentals.OrderByDescending(c => c.DateRented); break; case "bookTitle": rentals = rentals.OrderBy(c => c.Book.Title); break; case "bookTitle_desc": rentals = rentals.OrderByDescending(c => c.Book.Title); break; case "customerName": rentals = rentals.OrderBy(c => c.Customer.LastName); break; case "customerName_desc": rentals = rentals.OrderByDescending(c => c.Customer.LastName); break; default: rentals = rentals.OrderByDescending(c => c.DateRented); break; } var pagedList = rentals.ToPagedList(paging.PageNumber, paging.PageSize); if (pagedList.PageCount < pagedList.PageNumber) { return(rentals.ToPagedList(1, paging.PageSize)); } return(pagedList); }
/// <summary> /// Sorts input in ascending order using Cocktail sort technique /// </summary> /// <param name="sort">ISort</param> /// <param name="sortingAlgorithmFactory">Sorting algorithm factory</param> /// <param name="input">input data</param> /// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param> /// <returns>The ascending ordered content</returns> public static string UseCocktail(this ISorting sort, ISortingAlgorithmFactory sortingAlgorithmFactory, string input, IComparer <char> comparer = null) { return(sort.Sort(sortingAlgorithmFactory, SortingTypes.Cocktail, input, comparer)); }
public async Task <IEnumerable <UserIdentityDTO> > GetAllAsync(ISorting sorting, IFiltering filtering, IPaging paging) { var models = await userIdentityRepository.GetAllAsync(sorting, filtering, paging); return(models); }
public PlayerAction(ISorting sorting, IDrawing drawing) { this.sorting = sorting; this.drawing = drawing; }
/// <summary> /// Sorts input in ascending order using Cocktail sort technique /// </summary> /// <typeparam name="T">Type of data</typeparam> /// <param name="sort">ISort</param> /// <param name="sortingAlgorithmFactory">Sorting algorithm factory</param> /// <param name="input">input data</param> /// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param> public static void UseCocktail <T>(this ISorting sort, ISortingAlgorithmFactory sortingAlgorithmFactory, T[] input, IComparer <T> comparer) { sort.Sort <T>(sortingAlgorithmFactory, SortingTypes.Cocktail, input, comparer); }
public PressureAnalyzer(ISorting <PressureNode> sorting) { this.Sorting = sorting; }
public async Task <IEnumerable <RegistrationDTO> > GetAllAsync(ISorting sorting, IFiltering filtering, IPaging paging) { var models = await registrationRepository.GetAllAsync(sorting, filtering, paging); return(models); }
/// <summary> /// Sorts input in ascending order using Selection sort technique /// </summary> /// <typeparam name="T">Type of data</typeparam> /// <param name="sort">ISort</param> /// <param name="sortingAlgorithmFactory">Sorting algorithm factory</param> /// <param name="input">input data</param> /// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param> public static void UseSelection <T>(this ISorting sort, ISortingAlgorithmFactory sortingAlgorithmFactory, T[] input, IComparer <T> comparer) { sort.Sort <T>(sortingAlgorithmFactory, SortingTypes.Selection, input, comparer); }
/// <summary> /// Sorts input in ascending order using Selection sort technique /// </summary> /// <param name="sort">ISort</param> /// <param name="input">input data</param> /// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param> /// <returns>The ascending ordered content</returns> public static string UseSelection(this ISorting sort, string input, IComparer <char> comparer = null) { return(sort.Sort(SortingTypes.Selection, input, comparer)); }
private static bool SortingFieldSpecified(SortingHeader sortingHeader, ISorting sorting) { return(sortingHeader.ShouldSort && sorting.SortableFields.Contains(sortingHeader.SortBy, StringComparer.OrdinalIgnoreCase)); }
public static SortedQueryable <T> WithSorting <T>(this IQueryable <T> source, SortingHeader sortingHeader, ISorting sorting) { var validatedSortingHeader = DetermineSortingHeader <T>(sortingHeader, sorting); var orderedQueryable = validatedSortingHeader.SortOrder == SortOrder.Ascending ? source.OrderBy(validatedSortingHeader.SortBy) : source.OrderByDescending(validatedSortingHeader.SortBy); return(new SortedQueryable <T>(orderedQueryable, validatedSortingHeader)); }
private static SortingHeader DetermineSortingHeader <T>(SortingHeader sortingHeader, ISorting sorting) { return(SortingFieldSpecified(sortingHeader, sorting) ? sortingHeader : sorting.DefaultSortingHeader); }
public static IQueryable <T> Sort <T>(this IQueryable <T> query, ISorting sorting) => Sort(query, sorting, null);
public async Task <IEnumerable <IVehicleMakeDTO> > GetAllMakesAsync(IFilter filter, IPaging paging, ISorting sorting) { return(await vehicleMakeRepository.GetAllMakesAsync(filter, paging, sorting)); }
/// <summary> /// Sorts input in ascending order using Radix sort technique /// This techique currently supports only positive integer sorting /// </summary> /// <param name="sort">ISort</param> /// <param name="input">input data</param> /// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param> public static void UseRadix(this ISorting sort, int[] input, IComparer <int> comparer) { var radix = new RadixSort(comparer); radix.Sort(input); }
/// <summary> /// Sorts input in ascending order using Radix sort technique /// This techique currently supports only positive integer sorting /// </summary> /// <param name="sort">ISort</param> /// <param name="input">input data</param> /// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param> public static void UseRadix(this ISorting sort, int[] input) { var radix = new RadixSort(new IntegerComparer()); radix.Sort(input); }
/// <summary> /// Sorts input in ascending order using Selection sort technique /// </summary> /// <typeparam name="T">Type of data</typeparam> /// <param name="sort">ISort</param> /// <param name="input">input data</param> /// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param> public static void UseSelection <T>(this ISorting sort, T[] input, IComparer <T> comparer) { sort.Sort <T>(SortingTypes.Selection, input, comparer); }
/// <summary> /// Gets paged list of all VehicleModels. /// </summary> /// <param name="makeId"></param> /// <param name="filter"></param> /// <param name="paging"></param> /// <param name="sorting"></param> /// <returns> Paged list of all VehicleModels. </returns> public IPagedList<IVehicleModel> GetModels(Guid makeId, IFiltering filter, IPaging paging, ISorting sorting) { return vehicleModelRepository.GetModels(makeId, filter, paging, sorting); }
/// <summary> /// Sorts input in ascending order using Selection sort technique /// </summary> /// <param name="sort">ISort</param> /// <param name="sortingAlgorithmFactory">Sorting algorithm factory</param> /// <param name="input">input data</param> /// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param> /// <returns>The ascending ordered content</returns> public static string UseSelection(this ISorting sort, ISortingAlgorithmFactory sortingAlgorithmFactory, string input, IComparer <char> comparer = null) { return(sort.Sort(sortingAlgorithmFactory, SortingTypes.Selection, input, comparer)); }
/// <summary> /// Sorts input in ascending order using Bitonic sort technique. /// This will work only if the input size is power of 2 /// </summary> /// <typeparam name="T">Type of data</typeparam> /// <param name="sort">ISort</param> /// <param name="input">input data</param> /// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param> public static void UseBitonic <T>(this ISorting sort, T[] input, IComparer <T> comparer) { sort.Sort <T>(SortingTypes.Bitonic, input, comparer); }
public void Sorting(ISorting sortStrategy) { this._sortStrategy = sortStrategy; }
/// <summary> /// Sorts input in ascending order using Bitonic sort technique /// This will work only if the input size is power of 2 /// </summary> /// <typeparam name="T">Type of data</typeparam> /// <param name="sort">ISort</param> /// <param name="sortingAlgorithmFactory">Sorting algorithm factory</param> /// <param name="input">input data</param> /// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param> public static void UseBitonic <T>(this ISorting sort, ISortingAlgorithmFactory sortingAlgorithmFactory, T[] input, IComparer <T> comparer) { sort.Sort <T>(sortingAlgorithmFactory, SortingTypes.Bitonic, input, comparer); }
public async Task <IEnumerable <SeminarDTO> > GetAllAsync(ISorting sorting, IFiltering filtering, IPaging paging) { var models = await seminarRepository.GetAllAsync(sorting, filtering, paging); return(models); }
/// <summary> /// Sorts input in ascending order using Pancake sort technique /// </summary> /// <typeparam name="T">Type of data</typeparam> /// <param name="sort">ISort</param> /// <param name="input">input data</param> /// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param> public static void UsePancake <T>(this ISorting sort, T[] input, IComparer <T> comparer) { sort.Sort <T>(SortingTypes.Pancake, input, comparer); }
/// <summary> /// Sorts input in ascending order using Cocktail sort technique /// </summary> /// <typeparam name="T">Type of data</typeparam> /// <param name="sort">ISort</param> /// <param name="input">input data</param> /// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param> public static void UseCocktail <T>(this ISorting sort, T[] input, IComparer <T> comparer) { sort.Sort <T>(SortingTypes.Cocktail, input, comparer); }
/// <summary> /// Sorts input in ascending order using Pancake sort technique /// </summary> /// <typeparam name="T">Type of data</typeparam> /// <param name="sort">ISort</param> /// <param name="sortingAlgorithmFactory">Sorting algorithm factory</param> /// <param name="input">input data</param> /// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param> public static void UsePancake <T>(this ISorting sort, ISortingAlgorithmFactory sortingAlgorithmFactory, T[] input, IComparer <T> comparer) { sort.Sort <T>(sortingAlgorithmFactory, SortingTypes.Pancake, input, comparer); }
/// <summary> /// Sorts input in ascending order using Cocktail sort technique /// </summary> /// <param name="sort">ISort</param> /// <param name="input">input data</param> /// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param> /// <returns>The ascending ordered content</returns> public static string UseCocktail(this ISorting sort, string input, IComparer <char> comparer = null) { return(sort.Sort(SortingTypes.Cocktail, input, comparer)); }
/// <summary> /// Sorts input in ascending order using Heap sort technique /// </summary> /// <typeparam name="T">Type of data</typeparam> /// <param name="sort">ISort</param> /// <param name="input">input data</param> /// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param> public static void UseHeap <T>(this ISorting sort, T[] input, IComparer <T> comparer) { sort.Sort <T>(SortingTypes.Heap, input, comparer); }
public ProjectController(AppDbContext context, ISorting sorter) { _context = context; _sorter = sorter; }
/// <summary> /// Sorts input in ascending order using Heap sort technique /// </summary> /// <param name="sort">ISort</param> /// <param name="input">input data</param> /// <param name="comparer">Comparer must returns '1' if the first element is greater than next</param> /// <returns>The ascending ordered content</returns> public static string UseHeap(this ISorting sort, string input, IComparer <char> comparer = null) { return(sort.Sort(SortingTypes.Heap, input, comparer)); }
/// <summary> /// Gets all songs filtered, ordered, using pages /// </summary> /// <param name="filter">The filter.</param> /// <param name="options">The options.</param> /// <param name="orderBy">The string represeting how to order songs.</param> /// <param name="ascending">Whether to order ascending or descending.</param> /// <param name="pageNumber">The current page number.</param> /// <param name="pageSize">The page size.</param> /// <returns></returns> public async Task <IPagedList <ISong> > GetAsync(IFilter filter, string[] options, ISorting sortingOptions, IPaging pageOptions) { IQueryable <SongEntity> query = Repository.Get(options); IOrderedEnumerable <SongEntity> orderedQuery; Func <SongEntity, string> order; // filtering if (filter.Title != null) { query = query.Where(s => s.Title.Contains(filter.Title)); } // sorting switch (sortingOptions.SortBy) { case "title": order = s => s.Title; break; case "composer": order = s => s.Composer.Surname; break; case "arranger": order = s => s.Arranger.Surname; break; default: order = s => s.Title; break; } if (sortingOptions.SortAscending) { orderedQuery = query.OrderBy(order); } else { orderedQuery = query.OrderByDescending(order); } // paging IPagedList <SongEntity> songEntities = await orderedQuery.ToPagedListAsync(pageOptions.PageNumber, pageOptions.PageSize); IPagedList <ISong> result = new StaticPagedList <ISong>(Mapper.Map <IEnumerable <ISong> >(songEntities), songEntities.GetMetaData()); return(result); }
/// <summary> /// Gets paged list of all VehicleMakes. /// </summary> /// <param name="filter"></param> /// <param name="paging"></param> /// <param name="sorting"></param> /// <returns> A paged list of makes. </returns> public IPagedList<IVehicleMake> GetMakes(IFiltering filter, IPaging paging, ISorting sorting) { return vehicleMakeRepository.GetMakes(filter, paging, sorting); }