/// <summary> /// Gets the comparer for the field. /// </summary> /// <returns></returns> public IComparer GetComparerStrategy(CultureInfo culture) { // mbr - 2011-02-17 - this is wrong... it should use the type of the property... //return ComparerBase.GetComparer(this.DBType, culture); if (PropertyInfo == null) { throw new InvalidOperationException("'PropertyInfo' is null."); } return(ComparerBase.GetComparer(this.PropertyInfo.PropertyType, culture)); }
/// <summary> /// Adds sorting comparer to exiting DataRow comparer. /// </summary> /// <param name="orderBy">The existing DataRow comparer.</param> /// <param name="thenBy">The sorting comparer to add.</param> /// <returns>The result DataRow comparer.</returns> public static IDataRowComparer ThenBy(this IDataRowComparer orderBy, IDataRowComparer thenBy) { orderBy.VerifyNotNull(nameof(orderBy)); thenBy.VerifyNotNull(nameof(thenBy)); if (orderBy.ModelType != thenBy.ModelType) { throw new ArgumentException(DiagnosticMessages.DataRowComparer_DifferentDataRowModel, nameof(thenBy)); } return(ComparerBase.Create(orderBy, thenBy)); }
/// <summary> /// Adds additional sorting column to existing DataRow comparer. /// </summary> /// <typeparam name="T">Data type of column.</typeparam> /// <param name="orderBy">The existing DataRow comparer.</param> /// <param name="column">The additional sorting column.</param> /// <param name="direction">The sorting direction.</param> /// <param name="comparer">Data value comparer.</param> /// <returns>The result DataRow comparer.</returns> public static IDataRowComparer ThenBy <T>(this IDataRowComparer orderBy, Column <T> column, SortDirection direction = SortDirection.Ascending, IComparer <T> comparer = null) { orderBy.VerifyNotNull(nameof(orderBy)); var thenBy = DataRow.OrderBy(column, direction, comparer); if (orderBy.ModelType != thenBy.ModelType) { throw new ArgumentException(DiagnosticMessages.DataRowComparer_DifferentDataRowModel, nameof(column)); } return(ComparerBase.Create(orderBy, thenBy)); }
/// <summary> /// Sorts by the given column index. /// </summary> /// <param name="header"></param> private void Sort(EntityListViewColumnHeader header) { if (header == null) { throw new ArgumentNullException("header"); } // property... PropertyDescriptor property = header.Property; if (property == null) { throw new ArgumentNullException("property"); } // get a comparer... IComparer comparer = null; if (property is EntityFieldPropertyDescriptor) { comparer = ((EntityFieldPropertyDescriptor)property).Field.GetComparer(Cultures.User); } else { comparer = ComparerBase.GetComparer(property.PropertyType, Cultures.User); } // check... SortOrder useOrder = SortOrder.Ascending; if (this.SortColumn == header) { if (this.Sorting == SortOrder.Ascending) { useOrder = SortOrder.Descending; } else { useOrder = SortOrder.Ascending; } } // sort... SortDirection direction = SortDirection.Ascending; if (useOrder == SortOrder.Descending) { direction = SortDirection.Descending; } this.ListViewItemSorter = new EntityListViewComparer(header, comparer, direction); this.Sorting = useOrder; _sortColumn = header; }
private void InitializeCurrentSet() { if (Keys == null) { throw new InvalidOperationException("Keys is null."); } if (KeyField == null) { throw new InvalidOperationException("KeyFields is null."); } // build some ids... ArrayList ids = new ArrayList(); while (this.CurrentMasterPosition < this.Keys.Length && ids.Count < PageSize) { // add the current master position... ids.Add(this.Keys[this.CurrentMasterPosition][0]); // next... this.CurrentMasterPosition++; } // do we have anything? IList newSet = this.EntityType.CreateCollectionInstance(); if (ids.Count > 0) { // create a statement to load that lot... SqlFilter filter = new SqlFilter(this.EntityType); // if the master defines fields, we'll need the same ones... if (this.Source.Fields.Count > 0) { // add the fields - but we need to know if the key field is in there... bool keyFound = false; foreach (EntityField field in this.Source.Fields) { // found it? if (field == this.KeyField) { keyFound = true; } // add it... filter.Fields.Add(field); } // key? we'll need that to get the items in the right order... if (!(keyFound)) { filter.Fields.Add(this.KeyField); } } // build some sql... StringBuilder builder = new StringBuilder(); builder.Append(filter.Dialect.FormatColumnName(this.KeyField.Name)); builder.Append(" in ("); for (int index = 0; index < ids.Count; index++) { if (index > 0) { builder.Append(", "); } builder.Append(filter.Dialect.FormatVariableNameForQueryText(filter.ExtraParameters.Add(this.KeyField.DBType, ids[index]))); } builder.Append(")"); // add... filter.Constraints.AddFreeConstraint(builder.ToString()); // run it... IList newEntities = filter.ExecuteEntityCollection(); if (newEntities == null) { throw new InvalidOperationException("newEntities is null."); } // comparer... IComparer comparer = ComparerBase.GetComparer(this.KeyField.DBType, Cultures.System); if (comparer == null) { throw new InvalidOperationException("comparer is null."); } // we now have to get the data in the right order... object[] entities = new object[ids.Count]; for (int index = 0; index < ids.Count; index++) { // find it in the data set... foreach (object newEntity in newEntities) { object[] newKeys = this.EntityType.Storage.GetKeyValues(newEntity); if (newKeys == null) { throw new InvalidOperationException("newKeys is null."); } if (newKeys.Length != 1) { throw new InvalidOperationException("New keys length is invalid."); } // check... if (comparer.Compare(ids[index], newKeys[0]) == 0) { entities[index] = newEntity; break; } } } // create a new set from the ordered set... foreach (object entity in entities) { if (entity != null) { newSet.Add(entity); } else { switch (Mode) { // do nothing if skip missing... case OptimisticReadMode.SkipMissing: break; // add null in... case OptimisticReadMode.ThrowIfMissing: throw new InvalidOperationException("Item in keyset could not be found in the database."); default: throw new NotSupportedException(string.Format("Cannot handle '{0}' ({1}).", Mode, Mode.GetType())); } } } } // update... _currentSet = newSet; // position... _currentSetPosition = 0; }
private void DrawConstCompareField(ComparerBase comparer) { if (comparer.ConstValue == null) { comparer.ConstValue = comparer.GetDefaultConstValue(); } var so = new SerializedObject(comparer); var sp = so.FindProperty ("constantValueGeneric"); if (sp != null) { EditorGUILayout.PropertyField (sp, new GUIContent("Constant"), true); so.ApplyModifiedProperties (); } }
private void DrawObjectCompareField(ComparerBase comparer) { otherPathSelector.Draw(comparer.other, comparer, comparer.otherPropertyPath, comparer.GetAccepatbleTypesForB(), go => { comparer.other = go; AssertionExplorerWindow.Reload (); }, s => { comparer.otherPropertyPath = s; AssertionExplorerWindow.Reload (); } ); }
private void DrawCompareToType (ComparerBase comparer) { comparer.compareToType = (ComparerBase.CompareToType) EditorGUILayout.EnumPopup ("Compare to type", comparer.compareToType, EditorStyles.popup); if (comparer.compareToType == ComparerBase.CompareToType.CompareToConstantValue) { try { DrawConstCompareField(comparer); } catch (NotImplementedException) { Debug.LogWarning("This comparer can't compare to static value"); comparer.compareToType = ComparerBase.CompareToType.CompareToObject; } } else if (comparer.compareToType == ComparerBase.CompareToType.CompareToObject) { DrawObjectCompareField(comparer); } }
/// <summary> /// Gets the comparer for the field. /// </summary> /// <returns></returns> public IComparer GetComparerStrategy(CultureInfo culture) { return(ComparerBase.GetComparer(this.DBType, culture)); }
internal static IColumnComparer Create <T>(Column <T> column, SortDirection direction, IComparer <T> comparer) { return(ComparerBase.Create(column, direction, comparer)); }