public void SetSortIcon(int ColumnIndex, SortOrder Order) { IntPtr ColumnHeader = SendMessage(Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero); for (int ColumnNumber = 0; ColumnNumber <= Columns.Count - 1; ColumnNumber++) { IntPtr ColumnPtr = new IntPtr(ColumnNumber); LVCOLUMN lvColumn = new LVCOLUMN(); lvColumn.mask = HDI_FORMAT; SendMessageLVCOLUMN(ColumnHeader, HDM_GETITEM, ColumnPtr, ref lvColumn); if (!(Order == SortOrder.None) && ColumnNumber == ColumnIndex) { switch (Order) { case SortOrder.Ascending: lvColumn.fmt &= ~HDF_SORTDOWN; lvColumn.fmt |= HDF_SORTUP; break; case SortOrder.Descending: lvColumn.fmt &= ~HDF_SORTUP; lvColumn.fmt |= HDF_SORTDOWN; break; } } else { lvColumn.fmt &= ~HDF_SORTDOWN & ~HDF_SORTUP; } SendMessageLVCOLUMN(ColumnHeader, HDM_SETITEM, ColumnPtr, ref lvColumn); } }
public static Query OrderBy(this Query qry, string paramName, SortOrder order = SortOrder.Ascending) { if (paramName == null) throw Error.ArgumentNull("paramName"); qry.Sort = Tuple.Create(paramName, order); return qry; }
public SqlIndexedColumnExpression(SqlColumnExpression column, SortOrder sortOrder, bool lowercaseIndex) : base(typeof(void)) { this.Column = column; this.SortOrder = sortOrder; this.LowercaseIndex = lowercaseIndex; }
public async static Task<PagedList<Connection>> FindAllAsync(string type, string query = null, IEnumerable<string> fields = null, int page = 1, int pageSize = 20, string orderBy = null, SortOrder sortOrder = SortOrder.Descending) { var request = new FindAllConnectionsRequest() { Type = type, Query = query, PageNumber = page, PageSize = pageSize, OrderBy = orderBy, SortOrder = sortOrder }; var response = await request.ExecuteAsync(); if (response.Status.IsSuccessful == false) throw response.Status.ToFault(); var connections = new PagedList<Connection>() { PageNumber = response.PagingInfo.PageNumber, PageSize = response.PagingInfo.PageSize, TotalRecords = response.PagingInfo.TotalRecords, GetNextPage = async skip => await FindAllAsync(type, query, fields, page + skip + 1, pageSize) }; connections.AddRange(response.Connections); return connections; }
protected virtual List<BestMessageInfo> GetBestExistingData(string orderBy, SortOrder sortOrder, int count) { List<MessageData> list2; Assert.ArgumentNotNullOrEmpty(orderBy, "orderBy"); this.AssertOrderBy(orderBy); Guid managerRoot = this.managerRoot.InnerItem.ID.ToGuid(); List<BestMessageInfo> list = new List<BestMessageInfo>(); do { list2 = analyticsDataGateway.GetAllCampaignsSorted(managerRoot, orderBy, sortOrder); if (list2.Count == 0) { return list; } int num = Math.Min(list.Count + list2.Count, count); List<Guid> campaigns = new List<Guid>(); foreach (MessageData data in list2) { MessageItem message = this.FindMessage(data, managerRoot); if ((message != null) && (this.messageSentOnlyByContextUser(message))) { list.Add(this.CreateRow(message, data)); if (list.Count >= num) { return list; } } } this.analyticsDataGateway.MarkRemovedMessages(campaigns); } while (list2.Count >= 20); return list; }
public DataGridViewCustomSorter(DataGridView dgv) { myDataGridView = dgv; mySortTypeCode = Type.GetTypeCode(Type.GetType("System.String")); ColumnIndex = 0; OrderOfSort = SortOrder.None; }
public void HandleColumnClicked(System.Windows.Forms.ListView listView, ColumnClickEventArgs e) { // Determine if clicked column is already the column that is being sorted. if (e.Column == this.SortColumn) { // Reverse the current sort direction for this column. if (this.Order == SortOrder.Ascending) { this.Order = SortOrder.Descending; } else { this.Order = SortOrder.Ascending; } } else { // Set the column number that is to be sorted; default to ascending. this.SortColumn = e.Column; this.Order = SortOrder.Ascending; } // Perform the sort with these new sort options. listView.Sort(); }
public ListViewColumnSorter(bool sortByDate) { this.sortByDate = sortByDate; ColumnToSort = 0; OrderOfSort = SortOrder.None; ObjectCompare = new CaseInsensitiveComparer(); }
private bool TryParseSortOrder(string direction, out SortOrder sortOrder) { switch (direction.Trim().ToLower()) { case "asc": case "ascending": case "a": case "0": sortOrder = SortOrder.Ascending; return true; case "desc": case "descending": case "d": case "1": sortOrder = SortOrder.Descending; return true; case "": case null: sortOrder = SortOrder.Unspecified; return true; default: sortOrder = SortOrder.Unspecified; return false; } }
/// <summary> /// Initializes a new instance of the SorterBase class with the specified /// TableModel, Column index, IComparer and SortOrder /// </summary> /// <param name="tableModel">The TableModel that contains the data to be sorted</param> /// <param name="column">The index of the Column to be sorted</param> /// <param name="comparer">The IComparer used to sort the Column's Cells</param> /// <param name="sortOrder">Specifies how the Column is to be sorted</param> public SorterBase(TableModel tableModel, int column, IComparer comparer, SortOrder sortOrder) { this.tableModel = tableModel; this.column = column; this.comparer = comparer; this.sortOrder = sortOrder; }
public void ReverseSortOrder() { if (SortOrder == SortOrder.Ascending) SortOrder = SortOrder.Descending; else SortOrder = SortOrder.Ascending; }
public async static Task<PagedList<Article>> FindAllAsync(string type, string query = null, IEnumerable<string> fields = null, int page = 1, int pageSize = 20, string orderBy = null, SortOrder sortOrder = SortOrder.Descending ) { var service = ObjectFactory.Build<IArticleService>(); var request = new FindAllArticleRequest() { Type = type, Query = query, PageNumber = page, PageSize = pageSize, OrderBy = orderBy, SortOrder = sortOrder }; var response = await service.FindAllAsync(request); if (response.Status.IsSuccessful == false) throw response.Status.ToFault(); var articles = new PagedList<Article>() { PageNumber = response.PagingInfo.PageNumber, PageSize = response.PagingInfo.PageSize, TotalRecords = response.PagingInfo.TotalRecords, GetNextPage = async skip => await FindAllAsync(type, query, fields, page+skip+1, pageSize) }; articles.AddRange(response.Articles); return articles; }
private IList<Student> GetStudentsSorted(int pageIndex, int pageSize, string sortField, SortOrder order) { //Off course you are going to use a web service/wcf/EF call instead of this if (_students == null) { fillAllStudents(); } IList<Student> result= new List<Student>(); if (order == SortOrder.ASC) { if (sortField.ToLower() == "age") { _students.OrderBy(x => x.Age).Skip(pageSize * (pageIndex - 1)).Take(pageSize).ToList<Student>().ForEach(x=>result.Add(x)); } else { _students.OrderBy(x => x.Name).Skip(pageSize * (pageIndex - 1)).Take(pageSize).ToList<Student>().ForEach(x => result.Add(x)); } } else { if (sortField.ToLower() == "age") { _students.OrderByDescending(x => x.Age).Skip(pageSize * (pageIndex - 1)).Take(pageSize).ToList<Student>().ForEach(x => result.Add(x)); } else { _students.OrderByDescending(x => x.Name).Skip(pageSize * (pageIndex - 1)).Take(pageSize).ToList<Student>().ForEach(x => result.Add(x)); } } return result; }
public static void SetSortIcon(this ColumnHeader column, SortOrder order) { ListView listView = column.ListView; IntPtr columnHeader = SendMessage(listView.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero); for (int i = 0; i <= listView.Columns.Count - 1; i++) { IntPtr ColumnPtr = new IntPtr(i); LVCOLUMN lvColumn = new LVCOLUMN(); lvColumn.mask = HDI_FORMAT; SendMessage(columnHeader, HDM_GETITEM, ColumnPtr, ref lvColumn); if (!(order == SortOrder.None) && i == column.Index) { switch (order) { case SortOrder.Ascending: lvColumn.fmt &= ~HDF_SORTDOWN; lvColumn.fmt |= HDF_SORTUP; break; case SortOrder.Descending: lvColumn.fmt &= ~HDF_SORTUP; lvColumn.fmt |= HDF_SORTDOWN; break; } } else { lvColumn.fmt &= ~HDF_SORTDOWN & ~HDF_SORTUP; } SendMessage(columnHeader, HDM_SETITEM, ColumnPtr, ref lvColumn); } }
internal Sort(LocationField field, SortOrder order, double latitude, double longitude) { SortField = field; Order = order; Latitude = latitude; Longitude = longitude; }
/// <summary> /// Gets a paginated list of APObjects matching the given search criteria. /// </summary> /// <param name="type">The object type.</param> /// <param name="query">The search query for objects to be found.</param> /// <param name="fields">The object fields to be returned for the matching list of objects.</param> /// <param name="pageNumber">The page number.</param> /// <param name="pageSize">The page size.</param> /// <param name="orderBy">The object field on which the results should be sorted.</param> /// <param name="sortOrder">The sort order.</param> /// <param name="options">Request specific api options. These will override the global settings for the app for this request.</param> /// <returns>Paginated list of APObject objects matching the given search criteria.</returns> public async static Task<PagedList<APObject>> FindAllAsync(string type, IQuery query = null, IEnumerable<string> fields = null, int pageNumber = 1, int pageSize = 20, string orderBy = null, SortOrder sortOrder = SortOrder.Descending, ApiOptions options = null) { query = query ?? Query.None; var request = new FindAllObjectsRequest() { Type = type, Query = query.AsString().Escape(), PageNumber = pageNumber, PageSize = pageSize, OrderBy = orderBy, SortOrder = sortOrder }; if( fields != null ) request.Fields.AddRange(fields); ApiOptions.Apply(request, options); var response = await request.ExecuteAsync(); if (response.Status.IsSuccessful == false) throw response.Status.ToFault(); var objects = new PagedList<APObject>() { PageNumber = response.PagingInfo.PageNumber, PageSize = response.PagingInfo.PageSize, TotalRecords = response.PagingInfo.TotalRecords, GetNextPage = async skip => await FindAllAsync(type, query, fields, pageNumber + skip + 1, pageSize, orderBy, sortOrder, options) }; objects.AddRange(response.Objects); return objects; }
public static void SetSortIcons(ListView listView, int previouslySortedColumn, int newSortColumn, SortOrder sorting) { IntPtr headerHandle = SendMessage(listView.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero); IntPtr newColumn = new IntPtr(newSortColumn); IntPtr prevColumn = new IntPtr(previouslySortedColumn); HDITEM hditem; // Only update the previous item if it existed and if it was a different one. if (previouslySortedColumn != -1 && previouslySortedColumn != newSortColumn) { // Clear icon from the previous column. hditem = new HDITEM(); hditem.mask = HDI_FORMAT; ItemSendMessage(headerHandle, HDM_GETITEM, prevColumn, ref hditem); hditem.fmt &= ~HDF_SORTDOWN & ~HDF_SORTUP; ItemSendMessage(headerHandle, HDM_SETITEM, prevColumn, ref hditem); } // Set icon on the new column. hditem = new HDITEM(); hditem.mask = HDI_FORMAT; ItemSendMessage(headerHandle, HDM_GETITEM, newColumn, ref hditem); if (sorting == SortOrder.Ascending) { hditem.fmt &= ~HDF_SORTDOWN; hditem.fmt |= HDF_SORTUP; } else { hditem.fmt &= ~HDF_SORTUP; hditem.fmt |= HDF_SORTDOWN; } ItemSendMessage(headerHandle, HDM_SETITEM, newColumn, ref hditem); }
/// <summary> /// 构造函数 /// </summary> /// <param name="searcher">该字段所在的查询对象</param> /// <param name="columnName">字段名称</param> public SearchColumn(Searcher searcher, string columnName) { this.sortOrder = SortOrder.None; this.sortIndex = 1; this.columnName = columnName; this.currentSearcher = searcher; }
/// <summary> /// ... /// </summary> public ListViewItemComparer() { m_UseTagObject = false; m_SortColumn = 0; m_SortOrder = SortOrder.None; m_Comparer = new CaseInsensitiveComparer(); }
public StockReaderForm() { InitializeComponent(); stockDataGridView.AutoGenerateColumns = false; LoadConfigInfo(); BindColumns(); notifyIcon1.Visible = false; dataList = new SortableBindingList<TickerData>(); portfolioPath = ""; if (portfolio != null) ProcessTickers(); sortColumn = stockDataGridView.Columns[0]; sortOrder = stockDataGridView.SortOrder; //int interval = info.TimerInterval; if (config.ConfigData.Timer.interval <= 0) { tickerTimer.Interval = 60000; // default to 1 minute } else { tickerTimer.Interval = config.ConfigData.Timer.interval * 60000; } tickerTimer.Enabled = true; }
/// <summary> /// Sorts the <see cref="System.Data.DataTable"/>. /// </summary> /// <param name="sourceTable">The source table.</param> /// <param name="sortColumn">The column to sort by.</param> /// <param name="order">The <see cref="Tools.Common.SortOrder"/>.</param> /// <param name="copyIfNoSort">Should only be true when one table owner is assumed /// other time and space.</param> /// <returns></returns> public static DataTable SortDataTable(DataTable sourceTable, string sortColumn, SortOrder order, bool copyIfNoSort) { if (String.IsNullOrEmpty(sortColumn)) { // copyIfNoSort make the semantic more stable, even if there is no sort required // the copy is returned, so the caller may assume same level of independence. if (copyIfNoSort) return sourceTable.Copy(); return sourceTable; } DataTable targetTable = sourceTable.Clone(); DataRow[] sourceRows = sourceTable.Select(null, ("[" + sortColumn + "] " + order.ToString()).TrimEnd(' ')); for (int i = 0; i < sourceRows.Length; i++) { DataRow newRow = targetTable.NewRow(); newRow.ItemArray = sourceRows[i].ItemArray; targetTable.Rows.Add(newRow); } return targetTable; }
/// <summary> /// Find all playlists in this account. /// </summary> /// <param name="pageSize">Number of playlists returned per page. A page is a subset of all of the playlists that /// satisfy the request. The maximum page size is 50.</param> /// <param name="pageNumber">The zero-indexed number of the page to return.</param> /// <param name="sortBy">The property that you'd like to sort the results by.</param> /// <param name="sortOrder">The order that you'd like the results sorted - ascending or descending.</param> /// <param name="videoFields">A list of the fields you wish to have populated in the Videos /// contained in the playlists. If you omit this parameter, the method returns the following fields of the /// Video: id, name, shortDescription, longDescription, creationDate, publisheddate, lastModifiedDate, linkURL, /// linkText, tags, videoStillURL, thumbnailURL, referenceId, length, economics, playsTotal, playsTrailingWeek. /// If you use a token with URL access, this method also returns the Videos' FLVURL, renditions, FLVFullLength, /// videoFullLength.</param> /// <param name="playlistFields">A list of the fields you wish to have populated in the Playlists /// contained in the returned object. If you omit this parameter, all playlist fields are returned.</param> /// <param name="customFields">A list of the custom fields you wish to have populated in the videos /// contained in the returned object. If you omit this parameter, no custom fields are returned, unless you include /// the value 'customFields' in the video_fields parameter.</param> /// <param name="getItemCount">If true, also return how many total results there are.</param> /// <returns>A collection of Playlists that is the specified subset of all the playlists in this account.</returns> public BrightcoveItemCollection<BrightcovePlaylist> FindAllPlaylists(int pageSize, int pageNumber, SortBy sortBy, SortOrder sortOrder, IEnumerable<string> videoFields, IEnumerable<string> playlistFields, IEnumerable<string> customFields, bool getItemCount) { NameValueCollection parms = BuildBasicReadParams("find_all_playlists"); parms.Add("page_size", pageSize.ToString()); parms.Add("page_number", pageNumber.ToString()); parms.Add("sort_by", sortBy.ToBrightcoveName()); parms.Add("sort_order", sortOrder.ToBrightcoveName()); parms.Add("get_item_count", getItemCount.ToString().ToLower()); if (videoFields != null) { parms.AddRange("video_fields", videoFields); } if (playlistFields != null) { parms.AddRange("playlist_fields", playlistFields); } if (customFields != null) { parms.AddRange("custom_fields", customFields); } return RunQuery<BrightcoveItemCollection<BrightcovePlaylist>>(parms); }
/// <summary> /// Initializes a new instance of the <see cref="T:Switchvox.CallLogs.Search"/> class for searches where a single search criterion must be specified. /// </summary> /// <param name="startDate">The minimum date to search from.</param> /// <param name="endDate">The maximum date to search to.</param> /// <param name="searchData">A <see cref="Switchvox.CallLogs.Search.SingleItemSearchData"/> value representing the type of data this request will search for.</param> /// <param name="data">A single value corresponding with the type of data specified in <paramref name="searchData"/></param> /// <param name="sortOrder">How the response will be sorted</param> /// <param name="itemsPerPage">The maximum number of records to be returned by the response. An additional <paramref name="itemsPerPage"/> number of records can be retrieved by making additional requests and modifying the <paramref name="pageNumber"/></param> /// <param name="pageNumber">The page number of call record results to return.</param> public Search(DateTime startDate, DateTime endDate, SingleItemSearchData searchData, string data, SortOrder sortOrder = SortOrder.Desc, int itemsPerPage = 50, int pageNumber = 1) : base("switchvox.callLogs.search") { var searchDataElms = GetSingleItemSearchDataElms(searchData, data); ConstructXml(startDate, endDate, searchDataElms, sortOrder, itemsPerPage, pageNumber); }
public ListViewColumnSorter() { ColumnToSort = 0; OrderOfSort = SortOrder.None; numCompare = false; ObjectCompare = new CaseInsensitiveComparer(); }
/// <summary> /// Class constructor. Initializes various elements /// </summary> public ListViewColumnSorter() { // Initialize the sort order to 'none' _orderOfSort = SortOrder.None; // Initialize the CaseInsensitiveComparer object _objectCompare = new CaseInsensitiveComparer(CultureInfo.CurrentCulture); }
public SortFields Add(Range key, SortOn sortOn = SortOn.Values, SortOrder order = SortOrder.Ascending, SortDataOption dataOption = SortDataOption.Normal) { InternalObject.GetType().InvokeMember("Add", System.Reflection.BindingFlags.InvokeMethod, null, InternalObject, ComArguments.Prepare(key, sortOn, order, dataOption)); // I'm returning this since the documentation says it returns 'SortFields' not 'SortField' return this; }
/// <summary> /// call this from column click. /// </summary> /// <param name="lvs">an instance of listviewsorter</param> /// <param name="lv">The lv.</param> /// <param name="column">The column.</param> /// <param name="forceorder">if set to a value, will sort by that all the time, otherwise will sort as normal</param> public static void ColumnSort(ListViewSorter lvs, ListView lv, int column, SortOrder? forceorder = null) { try { lv.ListViewItemSorter = lvs; if (!(lv.ListViewItemSorter is ListViewSorter)) return; lvs = (ListViewSorter) lv.ListViewItemSorter; } catch (Exception) { return; } if (forceorder != null) { lv.Sorting = (SortOrder) forceorder; } else { //invert sorting lv.Sorting = lv.Sorting == SortOrder.Ascending ? SortOrder.Descending : SortOrder.Ascending; } lvs.ByColumn = column; lv.Sort(); }
//--------------------------------------------------------------------- public ListViewColumnSorter() { ColumnToSort = 0; OrderOfSort = SortOrder.None; ObjectCompare = new CaseInsensitiveComparer(); Order = SortOrder.Ascending; }
/// <summary>performance tip: expect to have only 1 order item</summary> public OrderBy(IExpression expr, SortOrder order) { orderByList = new List<Pair<IExpression, SortOrder>>(1) { new Pair<IExpression, SortOrder>(expr, order) }; }
public static SearchParams OrderBy(this SearchParams qry, string paramName, SortOrder order = SortOrder.Ascending) { if (paramName == null) throw Error.ArgumentNull("paramName"); qry.Sort.Add(Tuple.Create(paramName, order)); return qry; }
/// <summary> /// Initializes a new instance of class ListViewItemComparer /// </summary> /// <param name="column">Index of sorting column</param> /// <param name="order">Sort order</param> public ListViewItemComparer(int column, SortOrder order) { col = column; innerOrder = order; }
public ListViewSubItemComparerText(int col, SortOrder order) { _col = col; _order = order; }
public ListViewSubItemComparerText() { _col = 0; _order = SortOrder.Ascending; }
/// <summary> /// Initializes a new instance of the NumberComparer class with the specified /// TableModel, Column index and SortOrder /// </summary> /// <param name="tableModel">The TableModel that contains the data to be sorted</param> /// <param name="column">The index of the Column to be sorted</param> /// <param name="sortOrder">Specifies how the Column is to be sorted</param> public NumberComparer(TableModel tableModel, int column, SortOrder sortOrder) : base(tableModel, column, sortOrder) { }
public void SetSortIcon(int columnIndex, SortOrder order) { }
public ColumnInfo(string input, string output, int maxNumTerms = Defaults.MaxNumTerms, SortOrder sort = Defaults.Sort, string[] term = null, bool textKeyValues = false) { Input = input; Output = output; Sort = sort; MaxNumTerms = maxNumTerms; Term = term; TextKeyValues = textKeyValues; }
public static IQueryable <TEntity> Sort <TEntity>( this IQueryable <TEntity> queryable, SortOrder <TEntity> sortOrder) => sortOrder.Order == SortOrder <TEntity> .Descending ? queryable.OrderByDescending(sortOrder.ToExpression()) : queryable.OrderBy(sortOrder.ToExpression());
public ComboTextComparer(SortOrder order) { _modifier = (int)order; }
private static IOrderedQueryable <TEntity> InvokeSortBy <TEntity>(IQueryable <TEntity> query, Expression <Func <TEntity, dynamic> > sortPredicate, SortOrder sortOrder) where TEntity : class, new() { var param = sortPredicate.Parameters[0]; string propertyName = null; Type propertyType = null; Expression bodyExpression = null; if (sortPredicate.Body is UnaryExpression) { var unaryExpression = sortPredicate.Body as UnaryExpression; bodyExpression = unaryExpression.Operand; } else if (sortPredicate.Body is MemberExpression) { bodyExpression = sortPredicate.Body; } else { throw new ArgumentException(@"The body of the sort predicate expression should be either UnaryExpression or MemberExpression.", "sortPredicate"); } var memberExpression = (MemberExpression)bodyExpression; propertyName = memberExpression.Member.Name; if (memberExpression.Member.MemberType == MemberTypes.Property) { var propertyInfo = memberExpression.Member as PropertyInfo; if (propertyInfo != null) { propertyType = propertyInfo.PropertyType; } } else { throw new InvalidOperationException(@"Cannot evaluate the type of property since the member expression represented by the sort predicate expression does not contain a PropertyInfo object."); } var funcType = typeof(Func <,>).MakeGenericType(typeof(TEntity), propertyType); var convertedExpression = Expression.Lambda(funcType, Expression.Convert(Expression.Property(param, propertyName), propertyType), param); var sortingMethods = typeof(Queryable).GetMethods(BindingFlags.Public | BindingFlags.Static); var sortingMethodName = GetSortingMethodName(sortOrder); var sortingMethod = sortingMethods.First(sm => sm.Name == sortingMethodName && sm.GetParameters().Length == 2); return((IOrderedQueryable <TEntity>)sortingMethod .MakeGenericMethod(typeof(TEntity), propertyType) .Invoke(null, new object[] { query, convertedExpression })); }
/// <summary> /// Initializes a new instance of class ListViewItemComparer /// </summary> public ListViewItemComparer() { col = 0; innerOrder = SortOrder.Ascending; }
/// <summary> /// If set to asc or desc, the column will be sorted in that direction on first /// sort.Subsequent sorts of the column will toggle as usual (default: null) /// </summary> /// <param name = "firstSortOrder">First sort order</param> public Column SetFirstSortOrder(SortOrder firstSortOrder) { _firstSortOrder = firstSortOrder; return(this); }
public ComboValueComparer(SortOrder order) { _modifier = (int)order; }
/// <summary> /// Returns a new pivot everytime it is called recursively and swaps the array elements based on pivot value comparison. /// </summary> /// <param name="array">The array that should be sorted.</param> /// <param name="left">The left partition of <c>array</c>.</param> /// <param name="right">The right partition of <c>array</c>.</param> /// <param name="stringComparison">The instance of StringComparsion.</param> /// <param name="sortOrder">The sort order (Ascending or Descending).</param> /// <exception cref="ArgumentOutOfRangeException">Thrown when the pivot is out of range.</exception> /// <returns>The new pivot.</returns> private static int FindPartition(string[] array, int left, int right, StringComparison stringComparison, SortOrder sortOrder) { if (left < 0 || right < 0 || left > array.Length - 1 || right > array.Length - 1) { throw new ArgumentOutOfRangeException($"The pivot {left} or {right} is out of range"); } int i = left, j = right; string pivot = array[(left + right) / 2]; while (i <= j) { while ((sortOrder == SortOrder.Ascending) ? String.Compare(array[i], pivot, stringComparison) < 0 : String.Compare(array[i], pivot, stringComparison) > 0) { i++; } while ((sortOrder == SortOrder.Ascending) ? String.Compare(array[j], pivot, stringComparison) > 0 : String.Compare(array[j], pivot, stringComparison) < 0) { j--; } if (i <= j) { Swap(ref array[i], ref array[j]); i++; j--; } } return(i); }
//============================================================================* // Private Data Members //============================================================================* //============================================================================* // cListViewFirearmBulletComparer() - Constructor //============================================================================* public cListViewFirearmBulletComparer(int nSortColumn, SortOrder SortOrder) : base(nSortColumn, SortOrder) { }
/// <summary> /// Returns sorted array considering sortorder and sortcomparsion. /// </summary> /// <param name="array">The array that should be sorted.</param> /// <param name="stringComparison">The instance of StringComparsion.</param> /// <param name="sortOrder">The sort order (Ascending or Descending).</param> /// <exception cref="ArgumentNullException">Trown when array is null</exception> /// <returns>The sorted array of string</returns> public static string[] CustomSort(this string[] array, StringComparison stringComparison = StringComparison.OrdinalIgnoreCase, SortOrder sortOrder = SortOrder.Ascending) { if (array == null) { throw new ArgumentNullException(nameof(array)); } if (array.Length == 0) { return(array); } int left = 0; int right = array.Count() - 1; InternalQuickSort(array, left, right, stringComparison, sortOrder); return(array); }
public RssItemsListViewColumnSorter() { SortColumn = 0; orderOfSort = SortOrder.Descending; }
public static IList <T> QuickSort_Iterative <T>(IList <T> elements, SortOrder order) where T : IComparable { var borders = new Stack <Tuple <int, int> >(); borders.Push(Tuple.Create(0, elements.Count - 1)); var workers = new List <Thread>(); for (int i = 0; i < 10; i++) { workers.Add(new Thread(DoWork)); } workers.ForEach(w => w.Start()); while (!workers.TrueForAll(w => w.ThreadState == System.Threading.ThreadState.WaitSleepJoin)) { continue; } return(elements); void DoWork() { Tuple <int, int> area; int comp = (int)order; while (true) { var greater = new List <T>(); var lesser = new List <T>(); var equel = new List <T>(); lock (borders) { while (borders.Count == 0) { Monitor.Wait(borders); } area = borders.Pop(); } T pivot = elements[area.Item1 / 2 + area.Item2 / 2]; for (int i = area.Item1; i < area.Item2; i++) { T current = elements[i]; if (current.CompareTo(pivot) == comp) { lesser.Add(current); } else if (pivot.CompareTo(current) == comp) { greater.Add(current); } else { equel.Add(current); } } int l = area.Item1; foreach (var item in lesser.Concat(equel).Concat(greater)) { elements[l++] = item; } lock (borders) { if (lesser.Count > 1) { borders.Push(Tuple.Create(area.Item1, area.Item1 + lesser.Count)); } if (greater.Count > 1) { borders.Push(Tuple.Create(area.Item2 - greater.Count, area.Item2)); } Monitor.Pulse(borders); } } } }
/// <summary> /// Internal recursive sort algorithm for quick sort using divide and conquer. Sorting is done based on pivot /// </summary> /// <param name="array">The array that should be sorted.</param> /// <param name="left">The left partition of array.</param> /// <param name="right">The sort order (Ascending or Descending).</param> /// <param name="stringComparison">The instance of StringComparsion.</param> /// <param name="sortOrder">The sort order (Ascending or Descending).</param> private static void InternalQuickSort(string[] array, int left, int right, StringComparison stringComparison, SortOrder sortOrder) { int pivotNewIndex = FindPartition(array, left, right, stringComparison, sortOrder); if (left < pivotNewIndex - 1) { InternalQuickSort(array, left, pivotNewIndex - 1, stringComparison, sortOrder); } if (pivotNewIndex < right) { InternalQuickSort(array, pivotNewIndex, right, stringComparison, sortOrder); } }
private static IList <T> Sort <T>(IList <T> list, int start, int end, SortOrder order) where T : IComparable { return(QuickSort_Recursive(list, start, end, order)); }
public ListViewItemComparer(int sortColumn, SortOrder sortOrder) { _sortColumn = sortColumn; _sortOrder = sortOrder; }
public static IList <T> Sort <T>(IList <T> list, SortOrder order = SortOrder.Ascending) where T : IComparable { pass = 0; Sort(list, 0, list.Count - 1, order); return(list); }
public static IList <T> QuickSort_Recursive <T>(IList <T> elements, int start, int end, SortOrder order) where T : IComparable { int comp = (int)order; int left = start; int right = end; T pivot = elements[start / 2 + end / 2]; while (left < right) { while (elements[left].CompareTo(pivot) == comp) { left++; } while (pivot.CompareTo(elements[right]) == comp) { right--; } if (left <= right) // '=' needed to push the left and right away { T tmp = elements[left]; elements[left] = elements[right]; elements[right] = tmp; left++; right--; } } Thread th = null; if (start < right) //the sequence is now: start...right,left...end { if (pass++ < 0) { th = new Thread(() => Sort(elements, start, right, order)); th.Start(); } else { Sort(elements, start, right, order); } } if (left < end) { Sort(elements, left, end, order); } th?.Join(); return(elements); }
public static UserCollection Top(int count, QueryFilter where, string orderBy = null, SortOrder sortOrder = SortOrder.Ascending, Database database = null) { Database db = database ?? Db.For <User>(); QuerySet query = GetQuerySet(db); query.Top <User>(count); query.Where(where); if (orderBy != null) { query.OrderBy(orderBy, sortOrder); } query.Execute(db); var results = query.Results.As <UserCollection>(0); results.Database = db; return(results); }
public static void InsertionSort <T>(IList <T> elements, int start, int end, SortOrder order) where T : IComparable { int comp = (int)order; for (int i = start; i < end - 1; i++) { int j = i + 1; T current = elements[j]; while (j > start && current.CompareTo(elements[j - 1]) == comp) { elements[j] = elements[j - 1]; j--; } elements[j] = current; } }
/// <summary> /// Translates the given <see cref="SortOrder"/> into the string representation /// used in the XML. /// </summary> /// <param name="p_sorOrder">The <see cref="SortOrder"/> to unparse.</param> /// <returns>The string representation used in the XML for the given <see cref="SortOrder"/>.</returns> protected string UnparseSortOrder(SortOrder p_sorOrder) { return(p_sorOrder.ToString()); }
public SearchImages WithSortOrder(SortOrder value) { AddQueryParameter(Constants.SortOrderKey, value); return(this); }
protected void GVDoituong_Sorting(object sender, GridViewSortEventArgs e) { SortOrder = SortOrder.ToString().Equals("asc") ? "desc" : "asc"; SortExtension = e.SortExpression; BindList_Doituong(); }
/// <summary> /// Initializes a new instance of the <see cref="MailKit.UniqueIdSet"/> class. /// </summary> /// <remarks> /// Creates a new unique identifier set. /// </remarks> /// <param name="order">The sorting order to use for the unique identifiers.</param> /// <exception cref="System.ArgumentOutOfRangeException"> /// <paramref name="order"/> is invalid. /// </exception> public UniqueIdSet(SortOrder order = SortOrder.None) : this(0, order) { }
public OrderItem(Expression <Func <T, dynamic> > sortPredicate, SortOrder sortOrder) { this.sortPredicate = sortPredicate; this.sortOrder = sortOrder; }
private SortOrder toggleSort(SortOrder o) { return(o == SortOrder.Descending ? SortOrder.Ascending : SortOrder.Descending); }