/// <summary> /// Construct the object. /// </summary> /// /// <param name="theIndexindex">The index of the sorted field.</param> /// <param name="t">The type of sort, the type of object.</param> /// <param name="theAscending">True, if this is an ascending sort.</param> public SortedField(int theIndexindex, SortType t, bool theAscending) { _index = theIndexindex; Ascending = theAscending; _sortType = t; }
public override void DrawArrow(Context cr, Gdk.Rectangle alloc, SortType type) { cr.LineWidth = 1; cr.Translate (0.5, 0.5); double x1 = alloc.X; double x3 = alloc.X + alloc.Width / 2.0; double x2 = x3 + (x3 - x1); double y1 = alloc.Y; double y2 = alloc.Bottom; if (type == SortType.Ascending) { cr.MoveTo (x1, y1); cr.LineTo (x2, y1); cr.LineTo (x3, y2); cr.LineTo (x1, y1); } else { cr.MoveTo (x3, y1); cr.LineTo (x2, y2); cr.LineTo (x1, y2); cr.LineTo (x3, y1); } cr.SetSourceColor (Colors.GetWidgetColor (GtkColorClass.Base, StateType.Normal)); cr.FillPreserve (); cr.SetSourceColor (Colors.GetWidgetColor (GtkColorClass.Text, StateType.Normal)); cr.Stroke (); cr.Translate (-0.5, -0.5); }
/// <summary> /// Creates a field that holds <see cref="QueryTypeProperties{T}"/> for the module. /// </summary> protected FieldDeclarationSyntax CreatePropertiesField( Module module, string resultClassName, FieldDeclarationSyntax propsField, SortType? sortType) { var queryTypePropertiesType = SyntaxEx.GenericName("QueryTypeProperties", resultClassName); var propertiesInitializer = SyntaxEx.ObjectCreation( queryTypePropertiesType, SyntaxEx.Literal(module.Name), SyntaxEx.Literal(module.Prefix), module.QueryType == null ? (ExpressionSyntax)SyntaxEx.NullLiteral() : SyntaxEx.MemberAccess("QueryType", module.QueryType.ToString()), sortType == null ? (ExpressionSyntax)SyntaxEx.NullLiteral() : SyntaxEx.MemberAccess("SortType", sortType.ToString()), CreateTupleListExpression(GetBaseParameters(module)), propsField == null ? (ExpressionSyntax)SyntaxEx.NullLiteral() : (NamedNode)propsField, resultClassName == "object" ? (ExpressionSyntax)SyntaxEx.LambdaExpression("_", SyntaxEx.NullLiteral()) : SyntaxEx.MemberAccess(resultClassName, "Parse")); return SyntaxEx.FieldDeclaration( new[] { SyntaxKind.PrivateKeyword, SyntaxKind.StaticKeyword, SyntaxKind.ReadOnlyKeyword }, queryTypePropertiesType, ClassNameBase + "Properties", propertiesInitializer); }
public CChartParameter(string ip_chart_description, string ip_Order_col_name, string ip_Caption_col_name, string ip_Data_col_name, SortType ip_sort_type) { strCaptionColName = ip_Caption_col_name; strDataColName = ip_Data_col_name; strOrderColName = ip_Order_col_name; strCaptionOfChart = ip_chart_description; type = ip_sort_type; }
/// <summary> /// A simple class that holds a single sort criterion. /// </summary> /// <param name="property">The data class' property to sort on.</param> /// <param name="direction">The direction to sort based on the Property.</param> public SortOrder(string property, SortType direction) { if (property == null) { throw new ArgumentNullException("property", "Property must be a valid property/field name from the data class."); } Property = property; Direction = direction; }
public TwitchList<FollowedChannel> GetFollowedChannels(string user, PagingInfo pagingInfo = null, SortDirection sortDirection = SortDirection.desc, SortType sortType = SortType.created_at) { var request = GetRequest("users/{user}/follows/channels", Method.GET); request.AddUrlSegment("user", user); TwitchHelper.AddPaging(request, pagingInfo); request.AddParameter("direction", sortDirection); request.AddParameter("sortby", sortType); var response = restClient.Execute<TwitchList<FollowedChannel>>(request); return response.Data; }
public static EnumDescription[] GetFieldTexts(Type enumType, SortType sortType) { if (!EnumDescription.hashtable_0.Contains(enumType.FullName)) { FieldInfo[] fields = enumType.GetFields(); ArrayList arrayList = new ArrayList(); FieldInfo[] array = fields; for (int i = 0; i < array.Length; i++) { FieldInfo fieldInfo = array[i]; object[] customAttributes = fieldInfo.GetCustomAttributes(typeof(EnumDescription), false); if (customAttributes.Length == 1) { ((EnumDescription)customAttributes[0]).fieldInfo_0 = fieldInfo; arrayList.Add(customAttributes[0]); } } EnumDescription.hashtable_0.Add(enumType.FullName, arrayList.ToArray(typeof(EnumDescription))); } EnumDescription[] array2 = (EnumDescription[])EnumDescription.hashtable_0[enumType.FullName]; if (array2.Length <= 0) { int num = 0; while (num < array2.Length && sortType != SortType.Default) { for (int j = num; j < array2.Length; j++) { bool flag = false; switch (sortType) { case SortType.DisplayText: if (string.CompareOrdinal(array2[num].EnumDisplayText, array2[j].EnumDisplayText) > 0) { flag = true; } break; case SortType.Rank: if (array2[num].EnumRank > array2[j].EnumRank) { flag = true; } break; } if (flag) { EnumDescription enumDescription = array2[num]; array2[num] = array2[j]; array2[j] = enumDescription; } } num++; } } return array2; }
protected QueryTypeProperties( string moduleName, string prefix, QueryType? queryType, SortType? sortType, IEnumerable<Tuple<string, string>> baseParameters, IDictionary<string, string[]> props) { ModuleName = moduleName; Prefix = prefix; QueryType = queryType; SortType = sortType; BaseParameters = baseParameters; m_props = props ?? new Dictionary<string, string[]>(); }
private void CustomInitializeComponent() { var cfg = _provider.GetRequiredService<IRsdnForumService>().GetConfig(); _sortBy = cfg.ShowFullForumNames ? _sortByDesc : _sortByName; _sortType = cfg.ShowFullForumNames ? SortType.ByDesc : SortType.ByName; InitListView(false); }
public void Sort(Range key1=null, SortOrder? order1=null, Range key2 = null, SortType? type = null, SortOrder? order2 = null, Range key3 = null, SortOrder? order3 = null, YesNoGuess? header = YesNoGuess.No) { //if (!(key1 is String) && !(key1 is Range) && key1 != null) // throw new ArgumentException("Key1 must be a string (range named) or a range object"); //if (!(key2 is String) && !(key2 is Range) && key2 != null) // throw new ArgumentException("Key2 must be a string (range named) or a range object"); //if (!(key3 is String) && !(key3 is Range) && key3 != null) // throw new ArgumentException("Key3 must be a string (range named) or a range object"); InternalObject.GetType().InvokeMember("Sort", System.Reflection.BindingFlags.InvokeMethod, null, InternalObject, ComArguments.Prepare(key1, order1, key2, order2, key3, order3, header)); }
public FilterViewModel(int columnId, string columnName, SortType sortType, BindableCollection<FilterCriteriaViewModel> filterCriteria, VideoPlayerViewModel viewModel) { this.columnId = columnId; this.ColumnHeaderName = columnName; this.sortType = sortType; this.filterCriteria = filterCriteria; this.viewModel = viewModel; IsAscendingChecked = false; IsDescendingChecked = false; IsNoneChecked = true; ApplyButtonVisibility = "Visible"; RemoveButtonVisibility = "Collapsed"; CloseButtonVisibility = "Visible"; }
/// <summary> /// Constructor for Search operation. Takes in the following parameters /// to define the search filters to be used when the operation is executed. /// </summary> /// <param name="searchString">The string which the task name must contain to match the search.</param> /// <param name="startTime">The start time by which the task must within to match the search.</param> /// <param name="endTime">The end time by which the task must within to match the search.</param> /// <param name="isSpecific">The specificty of the time ranges.</param> /// <param name="searchType">The type of search filter to use in addition to the other filters.</param> /// <param name="sortType">The type of sort to sort the diplay list by after the operation is executed.</param> /// <returns>Response containing the search results, the operation's success or failure, and the new sort type if any.</returns> public OperationSearch( string searchString, DateTime? startTime, DateTime? endTime, DateTimeSpecificity isSpecific, SearchType searchType, SortType sortType) : base(sortType) { this.searchString = searchString; this.startTime = startTime; this.endTime = endTime; this.isSpecific = isSpecific; this.searchType = searchType; }
/// <summary> /// Sorts the items in a ListView in detail view by one of the columns, remembering previous sorting. /// </summary> /// <param name="list">ListView being sorted.</param> /// <param name="sortColumnIndex">Column to sort by.</param> /// <param name="sort">How to sort the data in the column.</param> /// <param name="reverse">True if list should be sorted in reverse order.</param> /// <param name="indicatorColumnIndex">Column to show sort indicator on.</param> public static void DetailSort(this ListView list, int sortColumnIndex, SortType sort, bool reverse, int indicatorColumnIndex) { if(list.View != View.Details) throw new ArgumentException(Properties.Resources.DetailsViewRequiredMessage, "list"); ListViewItemSorter sorter = list.ListViewItemSorter as ListViewItemSorter; if(sorter == null) { sorter = new ListViewItemSorter(sortColumnIndex, sort, reverse, indicatorColumnIndex); list.ListViewItemSorter = sorter; } else { if(sorter.IndicatorColumn != indicatorColumnIndex) HideSortIndicator(list, sorter.IndicatorColumn); sorter.SortBy(sortColumnIndex, sort, reverse, indicatorColumnIndex); } ShowSortIndicator(list, indicatorColumnIndex, reverse); list.Sort(); }
public MainWindowViewModel(MainWindow window) { _window = window; _selectedTasks = new List<Task>(); Log.LogLevel = User.Default.DebugLoggingOn ? LogLevel.Debug : LogLevel.Error; Log.Debug("Initializing Todotxt.net"); SortType = (SortType)User.Default.CurrentSort; if (!string.IsNullOrEmpty(User.Default.FilePath)) { LoadTasks(User.Default.FilePath); } }
/// <summary> /// This is the constructor for the Schedule operation. /// This operation accepts a time range and tries to schedule a task /// for the specified time period within the time range at the earliest /// possible point on execution.</summary> /// <param name="taskName">The name of the task to schedule.</param> /// <param name="startDateTime">The start date/time which the task should be scheduled within.</param> /// <param name="endDateTime">The end date/time which the task should be scheduled within.</param> /// <param name="isSpecific">The specificity of the start and end date time ranges.</param> /// <param name="timeRangeAmount">The numerical value of the task length of the task to be scheduled.</param> /// <param name="timeRangeType">The type of time length the task uses: hour, day, week or month.</param> /// <param name="sortType">The type of sort to sort the diplay list by after the operation is executed.</param> /// <returns>Nothing.</returns> public OperationSchedule( string taskName, DateTime startDateTime, DateTime? endDateTime, DateTimeSpecificity isSpecific, int timeRangeAmount, TimeRangeType timeRangeType, SortType sortType) : base(sortType) { this.taskName = taskName; this.startDateTime = startDateTime; this.endDateTime = endDateTime; this.isSpecific = isSpecific; this.taskDurationAmount = timeRangeAmount; this.taskDurationType = timeRangeType; }
/// <summary> /// This is the constructor for the Modify operation. /// It will modify the task indicated by the index range to the new /// parameters specified by the given arguments. If an arguement /// is left empty or null, that parameter will remain unchanged. /// </summary> /// <param name="taskName">The name of the task to modified. Can be a substring of it.</param> /// <param name="indexRange">The display index of the task to be modified.</param> /// <param name="startTime">The new start date to set for the task.</param> /// <param name="endTime">The new end date to set for the task.</param> /// <param name="isSpecific">The new Specificity of the dates for the task.</param> /// <param name="isAll">If this boolean is true, the operation will be invalid.</param> /// <param name="searchType">The type of search to be carried out (in addition to the other filters) if required.</param> /// <param name="sortType">The type of sort to sort the diplay list by after the operation is executed.</param> /// <returns>Nothing.</returns> public OperationModify(string taskName, int[] indexRange, DateTime? startTime, DateTime? endTime, DateTimeSpecificity isSpecific, bool isAll, SearchType searchType, SortType sortType) : base(sortType) { if (indexRange == null) hasIndex = false; else { hasIndex = true; this.startIndex = indexRange[TokenIndexRange.START_INDEX] - 1; this.endIndex = indexRange[TokenIndexRange.END_INDEX] - 1; } if (taskName == null) this.taskName = ""; else this.taskName = taskName; this.startTime = startTime; this.endTime = endTime; this.isSpecific = isSpecific; this.isAll = isAll; this.searchType = searchType; }
public static List<string> GetList(SortType type, int zone,int page,DateTime from,DateTime to) { Log.Info("正在获取排行 - 依据" + type.ToString().ToLower() + "/分区" + zone + "/分页" + page + "/时间" + from.ToString("yyyy-MM-dd") + "~" + to.ToString("yyyy-MM-dd")); string url = "http://www.bilibili.com/list/" + type.ToString() + "-" + zone + "-" + page + "-" + from.ToString("yyyy-MM-dd") + "~" + to.ToString("yyyy-MM-dd") + ".html"; string html = BiliInterface.GetHtml(url); if (html == null) return null; int p = 0; List<string> r = new List<string>(); while (html.IndexOf("o/av", p) > 0) { p = html.IndexOf("o/av", p); string s = html.Substring(p + 2, html.IndexOf("/", p + 2) - p - 2); if (!r.Contains(s)) r.Add(s); p += 3; } return r; }
private void SortItems(SortType sortType) { IOrderedEnumerable<ExplorerItem> sortedSource = null; if (sortType == SortType.Date) sortedSource = SortByDate(ExplorerItems); else if (sortType == SortType.Name) sortedSource = SortByName(ExplorerItems); else if (sortType == SortType.Size) sortedSource = SortBySize(ExplorerItems); else if (sortType == SortType.Type) sortedSource = SortByType(ExplorerItems); else if (sortType == SortType.None) return; if (sortedSource != null) { RerangeDataSource(sortedSource); _counterForLoadUnloadedItems = 0; } }
/// <summary> /// Initializes a new instance of the FlightResponseSettings with the specified parameters /// </summary> /// <param name="sortType">The property to sort on</param> /// <param name="sortOrder">Sort direction</param> /// <param name="maxStops">Filter for maximum number of stops. Between 0 and 3</param> /// <param name="maxDuration">Filter for maximum duration in minutes</param> /// <param name="outboundDepartureTime">Filter for outbound departure time by time period of the day </param> /// <param name="outboundDepartureStartTime">Filter for start of range for outbound departure time</param> /// <param name="outboundDepartureEndTime">Filter for end of range for outbound departure time</param> /// <param name="inboundDepartureTime">Filter for inbound departure time by time period of the day </param> /// <param name="inboundDepartureStartTime">Filter for start of range for inbound departure time</param> /// <param name="inboundDepartureEndTime">Filter for end of range for inbound departure time</param> /// <param name="originAirports">Origin airports to filter on. List of airport codes</param> /// <param name="destinationAirports">Destination airports to filter on. List of airport codes</param> /// <param name="includeCarriers">Filter flights by the specified carriers. Must be Iata carrier codes</param> /// <param name="excludeCarriers">Filter flights by any but the specified carriers. Must be Iata carrier codes</param> /// <param name="carrierSchema">The code schema to use for carriers</param> /// <param name="locationSchema">The code schema used for locations</param> public FlightResponseSettings( SortType sortType = SortType.Price, SortOrder sortOrder = SortOrder.Ascending, int? maxStops = null, int? maxDuration = null, DayTimePeriod? outboundDepartureTime = null, LocalTime? outboundDepartureStartTime = null, LocalTime? outboundDepartureEndTime = null, DayTimePeriod? inboundDepartureTime = null, LocalTime? inboundDepartureStartTime = null, LocalTime? inboundDepartureEndTime = null, IEnumerable<string> originAirports = null, IEnumerable<string> destinationAirports = null, IEnumerable<string> includeCarriers = null, IEnumerable<string> excludeCarriers = null, CarrierSchema carrierSchema = CarrierSchema.Iata, LocationSchema locationSchema = LocationSchema.Iata) { if (maxStops.HasValue && (maxStops.Value < 0 || maxStops.Value > 3)) { throw new ArgumentException("The filter for maximum number of stops must be between 0 and 3", nameof(maxStops)); } if (maxDuration.HasValue && (maxDuration.Value < 0 || maxDuration.Value > 1800)) { throw new ArgumentException("The filter for maximum duration must be between 0 and 1800", nameof(maxDuration)); } MaxDuration = maxDuration; MaxStops = maxStops; SortOrder = sortOrder; SortType = sortType; CarrierSchema = carrierSchema; LocationSchema = locationSchema; OriginAirports = originAirports; DestinationAirports = destinationAirports; IncludeCarriers = includeCarriers; ExcludeCarriers = excludeCarriers; OutboundDepartureTime = outboundDepartureTime; OutboundDepartureStartTime = outboundDepartureStartTime; OutboundDepartureEndTime = outboundDepartureEndTime; InboundDepartureTime = inboundDepartureTime; InboundDepartureStartTime = inboundDepartureStartTime; InboundDepartureEndTime = inboundDepartureEndTime; }
public ResponseResult<OrderModel> Get(int page, int page_size, DateTime start_date, DateTime end_date, OrderState order_state, string optional_fields = "", SortType sortType = SortType.Ase, DateType dateType = DateType.Modify_Time) { IJdClient client = new DefaultJdClient("","",""); //http://jos.jd.com/api/detail.htm?id=691 接口地址 var response = client.Execute(new UnionOrderServiceQueryOrdersRequest()); //判断 是否接受错误 可忽略 if (response.IsError) { } //对结果进行解析 理论上是响应的结果 var t = response.queryordersResult; //是一窜json格式 OrderModel需要 对响应结果解析并且转换 var parse=JsonConvert.DeserializeObject<OrderModel>(t); return new ResponseResult<OrderModel> { Code = int.Parse(response.ErrCode), Result = parse }; //throw new NotImplementedException(); }
public static void BubbleSort(int[] items, SortType sortOrder) { int i; int j; int temp; if (items == null) { return; } for (i = items.Length - 1; i >= 0; i--) { for (j = 1; j <= i; j++) { switch (sortOrder) { case SortType.Ascending: if (items[j - 1] > items[j]) { temp = items[j - 1]; items[j - 1] = items[j]; items[j] = temp; } break; case SortType.Descending: if (items[j - 1] < items[j]) { temp = items[j - 1]; items[j - 1] = items[j]; items[j] = temp; } break; } } } }
public static void LoadData() { string dataString = PlayerPrefs.GetString("Game_0"); if(dataString == null || dataString == "") { LoadDefaults(); return; } var rootDict = Json.Deserialize(dataString) as Dictionary<string,object>; if(rootDict == null) { LoadDefaults(); return; } if(rootDict.ContainsKey("sortType")) { _sortType = SortType.GetByName(rootDict["sortType"].ToString()); } List<object> playerDatas = rootDict["players"] as List<object>; for(int p = 0; p<playerDatas.Count; p++) { Dictionary<string,object> playerData = playerDatas[p] as Dictionary<string,object>; Player player = new Player(); player.name = playerData["name"].ToString(); player.color = PlayerColor.GetColor(playerData["color"].ToString()); player.score = int.Parse(playerData["score"].ToString()); _players.Add(player); } }
public void OnColumnClick(object sender, EventArgs args) { TreeViewColumn column = sender as TreeViewColumn; foreach (TreeViewColumn c in view.Columns) { if (c.SortColumnId != column.SortColumnId) c.SortIndicator = false; } if (currentSortColumnId == column.SortColumnId) { if (currentSortType == SortType.Ascending) currentSortType = SortType.Descending; else currentSortType = SortType.Ascending; } else { currentSortColumnId = column.SortColumnId; currentSortType = SortType.Ascending; } column.SortOrder = currentSortType; column.SortIndicator = true; store.SetSortColumnId (currentSortColumnId, currentSortType); }
private void OnSortChanged(SortType value) { view.SortType = sort = value; }
public SortingOptions(Expression <Func <T, object> > keySelector, bool isDescending = false) : this() { this.sortType = SortType.SortByExp; this.isDescending = isDescending; this.keySelector = keySelector; }
public void ThenSortBy(string sortProperty, bool isDescending = false) { this.thenSortType = SortType.SortByField; this.thenOrderBy = sortProperty; this.thenSortIsDescending = isDescending; }
public SortPropOrFieldAndDirection(string sPropOrFieldNameToSort, bool fDescendingSort, SortType sortTyp, StringComparison stringComp) { sPropertyOrFieldName = sPropOrFieldNameToSort; fSortDescending = fDescendingSort; sortType = sortTyp; stringComparison = stringComp; }
public INetSqlQueryable <TEntity, TEntity2, TEntity3, TEntity4, TEntity5, TEntity6, TEntity7> Order <TKey>(Expression <Func <TEntity, TEntity2, TEntity3, TEntity4, TEntity5, TEntity6, TEntity7, TKey> > expression, SortType sortType) { QueryBody.SetOrderBy(expression, sortType); return(this); }
/// <summary> /// 得到枚举类型定义的所有文本 /// </summary> /// <exception cref="NotSupportedException"></exception> /// <param name="enumType">枚举类型</param> /// <param name="sortType">指定排序类型</param> /// <returns>所有定义的文本</returns> public static EnumDescription[] GetFieldTexts(Type enumType, SortType sortType) { EnumDescription[] descriptions = null; //缓存中没有找到,通过反射获得字段的描述信息 if (cachedEnum.Contains(enumType.FullName) == false) { FieldInfo[] fields = enumType.GetFields(); ArrayList edAL = new ArrayList(); foreach (FieldInfo fi in fields) { object[] eds = fi.GetCustomAttributes(typeof(EnumDescription), false); if (eds.Length != 1) { continue; } ((EnumDescription)eds[0]).fieldIno = fi; edAL.Add(eds[0]); } cachedEnum.Add(enumType.FullName, (EnumDescription[])edAL.ToArray(typeof(EnumDescription))); } descriptions = (EnumDescription[])cachedEnum[enumType.FullName]; if (descriptions.Length <= 0) { throw new NotSupportedException("枚举类型[" + enumType.Name + "]未定义属性EnumValueDescription"); } //按指定的属性冒泡排序 for (int m = 0; m < descriptions.Length; m++) { //默认就不排序了 if (sortType == SortType.Default) { break; } for (int n = m; n < descriptions.Length; n++) { EnumDescription temp; bool swap = false; switch (sortType) { case SortType.Default: break; case SortType.DisplayText: if (string.Compare(descriptions[m].EnumDisplayText, descriptions[n].EnumDisplayText) > 0) { swap = true; } break; case SortType.Rank: if (descriptions[m].EnumRank > descriptions[n].EnumRank) { swap = true; } break; } if (swap) { temp = descriptions[m]; descriptions[m] = descriptions[n]; descriptions[n] = temp; } } } return(descriptions); }
public long SortAndStore(string destination, long skip = 0, long take = -1, Order order = Order.Ascending, SortType sortType = SortType.Numeric, T by = default(T), T[] get = null, CommandFlags flags = CommandFlags.None) => Wrapper.Database.SortAndStore($"{Wrapper.KeyPrefix}{RedisManager.RedisConfiguration.KeySeparator}{destination}", _realKey, skip, take, order, sortType, Wrapper.Wrap(by), get?.Select(_ => Wrapper.Wrap(_)).ToArray(), flags);
public T[] Sort(long skip = 0, long take = -1, Order order = Order.Ascending, SortType sortType = SortType.Numeric, T by = default(T), T[] get = null, CommandFlags flags = CommandFlags.None) => Wrapper.Unwrap <T>( () => Wrapper.Database .Sort(_realKey, skip, take, order, sortType, Wrapper.Wrap(by), get?.Select(_ => Wrapper.Wrap(_)).ToArray(), flags) );
/// <summary> /// 解析函数 /// </summary> /// <param name="callExp"></param> /// <param name="funcName"></param> /// <param name="sortType"></param> private void ResolveSelectForFunc(MethodCallExpression callExp, string funcName, SortType sortType) { if (callExp.Arguments[0] is UnaryExpression unary && unary.Operand is LambdaExpression lambda) { var colName = GetColumnName(lambda.Body as MemberExpression, lambda); Sorts.Add(new Sort($"{funcName}({colName})", sortType)); } }
private void SetOrderByForSubstring(MethodCallExpression callExp, LambdaExpression fullExpression, SortType sortType) { if (callExp.Object is MemberExpression objExp && objExp.Expression.NodeType == ExpressionType.Parameter) { var funcName = _sqlAdapter.FuncSubstring; var colName = GetColumnName(objExp, fullExpression); var start = ((ConstantExpression)callExp.Arguments[0]).Value.ToInt() + 1; if (callExp.Arguments.Count > 1 || _sqlAdapter.SqlDialect != SqlDialect.SqlServer) { var length = ((ConstantExpression)callExp.Arguments[1]).Value.ToInt(); var name = $"{funcName}({colName},{start},{length})"; Sorts.Add(new Sort(name, sortType)); } else { var name = $"{funcName}({colName},{start})"; Sorts.Add(new Sort(name, sortType)); } } }
private void SetOrderByMethod(LambdaExpression expression, MethodCallExpression methodCallExp, SortType sortType = SortType.Asc) { var methodName = methodCallExp.Method.Name.ToUpper(); switch (methodName) { case "SUBSTRING": SetOrderByForSubstring(methodCallExp, expression, sortType); return; case "COUNT": Sorts.Add(new Sort("COUNT(0)", sortType)); return; case "SUM": case "AVG": case "MAX": case "MIN": ResolveSelectForFunc(methodCallExp, methodName, sortType); return; } }
private void SetOrderByForMember(MemberExpression memberExp, LambdaExpression fullExpression, SortType sortType) { if (memberExp.Expression.NodeType == ExpressionType.MemberAccess) { //分组查询 if (IsGroupBy) { var descriptor = GroupByPropertyList.FirstOrDefault(m => m.Alias == memberExp.Member.Name); if (descriptor != null) { var colName = GetColumnName(descriptor.Name, descriptor.JoinDescriptor); Sorts.Add(new Sort(colName, sortType)); } } else { if (memberExp.Expression.Type.IsString()) { var memberName = memberExp.Member.Name.Equals("Length"); //解析Length函数 if (memberName) { var funcName = _sqlAdapter.FuncLength; var colName = GetColumnName(memberExp.Expression as MemberExpression, fullExpression); Sorts.Add(new Sort($"{funcName}({colName})", sortType)); } } } } else { var colName = GetColumnName(memberExp, fullExpression); Sorts.Add(new Sort(colName, sortType)); } }
private static List<MsgBase> GetOldStyleTopicList( IServiceProvider provider, int forumId, SortType sort, bool loadAll, MsgBase parent) { using (var db = provider.CreateDBContext()) { var displayConfig = Config.Instance.ForumDisplayConfig; var q = AppendSortPredicate(db.TopicInfos(ti => ti.ForumID == forumId), sort); if (displayConfig.ShowUnreadThreadsOnly) q = q.Where(ti => !ti.Message.IsRead || ti.AnswersUnread > 0); if (!(loadAll || displayConfig.MaxTopicsPerForum <= 0)) q = q.Take(displayConfig.MaxTopicsPerForum); var msgs = q .Select( ti => new Msg(provider) { Parent = parent, IsChild = false, ID = ti.MessageID, ParentID = 0, ForumID = ti.ForumID, Name = ti.Message.Name, Date = ti.Message.Date, Subject = ti.Message.Subject, UserID = ti.Message.UserID, UserClass = (short)ti.Message.UserClass, UserNick = ti.Message.UserNick, IsRead = ti.Message.IsRead, IsMarked = ti.Message.IsMarked, Closed = ti.Message.Closed, ReadReplies = ti.Message.ReadReplies, LastModerated = ti.Message.LastModerated, ArticleId = ti.Message.ArticleId, Rating = ti.SelfRates, Smiles = ti.SelfSmiles, Agrees = ti.SelfAgrees, Disagrees = ti.SelfDisagrees, Moderatorials = ti.SelfModeratorials, RepliesCount = ti.AnswersCount, RepliesUnread = ti.AnswersUnread, RepliesRate = ti.AnswersRates, RepliesSmiles = ti.AnswersSmiles, RepliesAgree = ti.AnswersAgrees, RepliesDisagree = ti.AnswersDisagrees, RepliesToMeUnread = ti.AnswersToMeUnread, RepliesMarked = ti.AnswersMarked, RepliesModeratorials = ti.AnswersModeratorials }) .Cast<MsgBase>() .ToList(); foreach (var msg in msgs) msg.EndMapping(); return msgs; } }
public override int GetHashCode() { unchecked { return(Ascending.GetHashCode() ^ (Labels != null ? Labels.GetHashCode() : 0) ^ Open.GetHashCode() ^ Since.GetHashCode() ^ SortType.GetHashCode() ^ (Mentioned != null ? Mentioned.GetHashCode() : 0) ^ (Creator != null ? Creator.GetHashCode() : 0) ^ (Assignee != null ? Assignee.GetHashCode() : 0) ^ (Milestone != null ? Milestone.GetHashCode() : 0)); } }
/// <summary> /// 构造器 /// </summary> /// <param name="mColName"></param> public QueryFieldItem(String mColName) { ProjectName = string.Empty; ColName = mColName; IsShow = false; sortType = SortType.NoSort; }
/// <summary> /// Sorts the list according to the point values at the specified index and /// for the specified axis. /// </summary> public void Sort(SortType type, int index) { this.Sort(new CurveItem.Comparer(type, index)); }
private List <Activities> GetSortedList(int startSortingAt, List <Activities> activitiesList, SortType sortType) { var baseList = activitiesList; if (startSortingAt == 0) { if (sortType == SortType.Ascending) { baseList = baseList.OrderBy(x => x.ActivityDescription).ToList(); } if (sortType == SortType.Descending) { baseList = baseList.OrderByDescending(x => x.ActivityDescription).ToList(); } foreach (var child in baseList) { SortList(sortType, child); } } else { var lookingFor = baseList.Select(item => Activities.Find(item, startSortingAt)).FirstOrDefault(activity => activity != null); SortList(sortType, lookingFor); } return(baseList); }
public void ThenSortBy(Expression <Func <T, object> > keySelector, bool isDescending = false) { this.thenSortType = SortType.SortByExp; this.thenKeySelector = keySelector; this.thenSortIsDescending = isDescending; }
public Sort(string propertyName, SortType sortType, int sortOrder) { PropertyName = propertyName; SortType = sortType; SortOrder = sortOrder; }
public VideoFolder SortList(SortType sorttype, VideoFolder parent) { return(GetSortService.SortList(sorttype, parent)); }
public void GetRootDetails(SortType sorttype, ref VideoFolder ParentDir) { ParentDir.FileType = FileType.Folder; ParentDir = SortList(sorttype, ParentDir); }
public SortingOptions(long columnIndex, bool isDescending = false) : this() { this.sortType = SortType.SortByExp; this.isDescending = isDescending; this.columnIndex = columnIndex; }
public VideoFolder LoadParentFiles(VideoFolder Parentdir, IList <DirectoryInfo> SubDirectory, IList <FileInfo> SubFiles, SortType sorttype) { VideoFolder videoFolder = new VideoFolder(Parentdir, SubDirectory[0].Parent.FullName); var children = new ObservableCollection <VideoFolder>(); children = LoadChildrenFiles(videoFolder, SubFiles); LoadParentSubDirectories(SubDirectory, children, videoFolder); videoFolder.OtherFiles = children; GetFolderItems(videoFolder); MovieDataSource.InitFileLoading(); return(videoFolder); }
public SortingOptions(string sortProperty, bool isDescending = false) : this() { this.sortType = SortType.SortByField; this.isDescending = isDescending; this.orderBy = sortProperty; }
public QuickDualPivotSortBinaryInsertTests() { sort = new QuickDualPivotSortBinaryInsert <int>(); algorithm = nameof(QuickDualPivotSortBinaryInsert <int>); sortType = SortType.Partition; }
public SortPropOrFieldAndDirection(string sPropOrFieldNameToSort, SortType sortTyp) { sPropertyOrFieldName = sPropOrFieldNameToSort; sortType = sortTyp; }
/// <summary> /// Processes a single file. /// </summary> /// <param name="type"> /// The sort type to use. /// </param> /// <param name="file"> /// The file to process. /// </param> /// <param name="destination"> /// The destination to process the files to. /// </param> private void ProcessFile(SortType type, FileResult file, IDirectoryInfo destination) { IFileInfo destinationInfo = file.GetFullPath(destination, this.storageProvider); if (destinationInfo.Directory != null && !destinationInfo.Directory.Exists) { destinationInfo.Directory.Create(); } else { if (!this.HandleRenameAndOverwrite(file, destination, ref destinationInfo)) { return; } } if (destinationInfo.Exists) { Logger.OnLogMessage(this, "Skipping {0}. Already exists.", LogType.Info, destinationInfo.Name.Truncate()); return; } switch (type) { case SortType.Move: file.InputFile.MoveTo(destinationInfo.FullName); Logger.OnLogMessage(this, "Moved {0}", LogType.Info, file.InputFile.Name.Truncate()); if (this.settings.DeleteEmptySubdirectories) { this.DeleteEmptySubdirectories(file); } break; case SortType.Copy: file.InputFile.CopyTo(destinationInfo.FullName); Logger.OnLogMessage(this, "Copied {0}", LogType.Info, file.InputFile.Name.Truncate()); break; } foreach (var episode in file.Episodes) { episode.FileCount++; episode.Save(this.storageProvider); } }
private static IQueryable<ITopicInfo> AppendSortPredicate( IQueryable<ITopicInfo> source, SortType sort) { switch (sort) { case SortType.ByLastUpdateDateDesc: return source.OrderByDescending(ti => ti.LastUpdateDate); case SortType.ByLastUpdateDateAsc: return source.OrderBy(ti => ti.LastUpdateDate ?? ti.Message.Date); case SortType.ByDateAsc: return source.OrderBy(ti => ti.Message.Date); case SortType.ByDateDesc: return source.OrderByDescending(ti => ti.Message.Date); case SortType.ByIdAsc: return source.OrderBy(ti => ti.MessageID); case SortType.ByIdDesc: return source.OrderByDescending(ti => ti.MessageID); case SortType.BySubjectAsc: return source.OrderBy(ti => ti.Message.Subject); case SortType.BySubjectDesc: return source.OrderByDescending(ti => ti.Message.Subject); case SortType.ByAuthorAsc: return source.OrderBy(ti => ti.Message.UserNick); case SortType.ByAuthorDesc: return source.OrderByDescending(ti => ti.Message.UserNick); //case SortType.ByForumAsc: //case SortType.ByForumDesc: default: throw new ArgumentOutOfRangeException("sort"); } }
public SortFieldAndDirection(string sPropOrFieldNameToSort, bool fDescendingSort, SortType sortTyp) : base(sPropOrFieldNameToSort, fDescendingSort, sortTyp) { }
void FilterAndSort(SortType sort) { if (_currentSort != sort) { User.Default.CurrentSort = (int)sort; User.Default.Save(); _currentSort = sort; } if (_taskList != null) { var selected = lbTasks.SelectedItem as Task; var selectedIndex = lbTasks.SelectedIndex; lbTasks.ItemsSource = _taskList.Sort(_currentSort, User.Default.FilterCaseSensitive, User.Default.FilterText); if (selected == null) { lbTasks.SelectedIndex = 0; } else { object match = null; foreach (var item in lbTasks.Items) { if (((Task)item).Body.Equals(selected.Body, StringComparison.InvariantCultureIgnoreCase)) { match = item; break; } } if (match == null) { lbTasks.SelectedIndex = selectedIndex; } else { lbTasks.SelectedItem = match; lbTasks.ScrollIntoView(match); } } } }
public async Task <List <Product> > LoadProductsInCategory(string categoryId, int offset = 0, int count = 10, string searchText = null, List <ApplyedFilter> filters = null, SortType sort = null) { await Task.Delay(500); if (offset > 20) { return(new List <Product>()); } return(string.IsNullOrEmpty(searchText) ? _products.Select(x => { x.Name = x.Name + categoryId; return x; }).ToList() : _products.Where(x => searchText.Contains(" ") ? searchText.ToLowerInvariant().Split(' ').Any(y => x.Name.ToLowerInvariant().Contains(y)) : x.Name.ToLowerInvariant().Contains(searchText.ToLowerInvariant())).ToList()); }
/// <summary> /// Processes the specified list of files. /// </summary> /// <param name="files"> /// The list of files to process. /// </param> /// <param name="type"> /// The operation to perform on the files. /// </param> /// <param name="defaultDestination"> /// The destination to process the files into. /// </param> internal void ProcessFiles(IEnumerable<FileResult> files, SortType type, IDirectoryInfo defaultDestination) { foreach (FileResult file in files) { if (file.Incomplete) { Logger.OnLogMessage(this, "Skipping {0}. Not enough information.", LogType.Error, file.InputFile.Name.Truncate()); continue; } var showDestination = defaultDestination; if (file.Show.UseCustomDestination) { showDestination = file.Show.GetCustomDestinationDirectory(); } this.ProcessFile(type, file, showDestination); } }
/// <summary> /// Constructor for PointPairComparer. /// </summary> /// <param name="type">The axis type on which to sort.</param> public PointPairComparer(SortType type) { this.sortType = type; }
public static void Sort <T>(T[] array, SortType sortType) where T : IComparable, new() { SortIteration(array, array.Length, sortType); }
public SortPropertyAndDirection(string sPropOrFieldNameToSort, SortType sortTyp) : base(sPropOrFieldNameToSort, sortTyp) { }
/// <summary> /// Constructor for PointPairComparer. /// </summary> /// <param name="type">The axis type on which to sort.</param> public PointPairComparer( SortType type ) { this.sortType = type; }
public Sort(string propertyName, SortType sortType) : this(propertyName, sortType, 0) { }