public GroupComparerDecorator(GroupComparer groupComparer, SortOrder sortOrder, IAggregateResultProvider results, DataAxis axis) { this.groupComparer = groupComparer; this.results = results; this.axis = axis; this.sortOrderMultiplier = sortOrder == SortOrder.Descending ? -1 : 1; }
internal DataSettings() { this.FilterDescriptions = new DescriptionsSettingsList <TFilter>(this); this.RowGroupDescriptions = new DescriptionsSettingsList <TGroup>(this); this.ColumnGroupDescriptions = new DescriptionsSettingsList <TGroup>(this); this.AggregateDescriptions = new DescriptionsSettingsList <TAggregate>(this); this.SortDescriptions = new DescriptionsSettingsList <TSort>(this); this.aggregatesLevel = -1; this.aggregatesPosition = DataAxis.Columns; }
private static List <IGroup> GetGroupsAtLevel(DataAxis axis, int level) { List <IGroup> groups = new List <IGroup>(); Coordinate root = resultProvider.Root; if (axis == DataAxis.Rows) { GetSubGroups(root.RowGroup, groups, level); } else { GetSubGroups(root.ColumnGroup, groups, level); } return(groups); }
/// <summary> /// Compares two <see cref="IGroup"/>s based on their grand totals. /// </summary> /// <param name="results">The current aggregate results.</param> /// <param name="left">The first <see cref="IGroup"/> to compare.</param> /// <param name="right">The second <see cref="IGroup"/> to compare.</param> /// <param name="axis">Identifies if the groups are in <see cref="DataAxis.Rows"/> or <see cref="DataAxis.Columns"/>.</param> /// <returns> /// A signed integer that indicates the relative values of x and y, as shown in the following table. /// <para>Value Meaning Less than zero x is less than y.</para> /// <para>Zero x equals y.</para> /// <para>Greater than zero x is greater than y.</para> /// </returns> public override int CompareGroups(IAggregateResultProvider results, IGroup left, IGroup right, DataAxis axis) { Coordinate grandTotalCoordinateX; Coordinate grandTotalCoordinateY; if (axis == DataAxis.Rows) { grandTotalCoordinateX = new Coordinate(left, results.Root.ColumnGroup); grandTotalCoordinateY = new Coordinate(right, results.Root.ColumnGroup); } else { grandTotalCoordinateX = new Coordinate(results.Root.RowGroup, left); grandTotalCoordinateY = new Coordinate(results.Root.RowGroup, right); } AggregateValue aggregateValueX = results.GetAggregateResult(this.AggregateIndex, grandTotalCoordinateX); AggregateValue aggregateValueY = results.GetAggregateResult(this.AggregateIndex, grandTotalCoordinateY); // TODO: Exception handling, Provide AggregateResults Comparer, Proper order on value-vs-null and null-vs-value cases if (aggregateValueX != null && aggregateValueY != null) { object valueX = aggregateValueX.GetValue(); object valueY = aggregateValueY.GetValue(); IComparable comparableX = valueX as IComparable; if (comparableX != null) { return(comparableX.CompareTo(valueY)); } IComparable comparableY = valueY as IComparable; if (comparableY != null) { return(-comparableY.CompareTo(valueX)); } } return(0); }
// TODO: Consider wrapping the IGroups in small objects that has settable 'IsFiltered' property similar to the TotalValue that has settable 'FormattedValue'. // TODO: Or the other way around - make them both return an ISet/IDictionary implementations that contain the filtered groups / values for groups. /// <summary> /// Filters the groups within a parent group. Can filter based on count, average values or sorted values. /// </summary> /// <param name="groups">A read only list of all siblings.</param> /// <param name="results">The current aggregate results.</param> /// <param name="axis">Identifies if the groups are in <see cref="DataAxis.Rows"/> or <see cref="DataAxis.Columns"/>.</param> /// <param name="level">The level of the groups.</param> /// <returns>A <see cref="ICollection{IGroup}"/> implementation that is used to filter the groups.</returns> protected internal abstract ICollection <IGroup> Filter(IReadOnlyList <object> groups, IAggregateResultProvider results, DataAxis axis, int level);
public override int CompareGroups(IAggregateResultProvider results, IGroup x, IGroup y, DataAxis axis) { throw new NotImplementedException(); }
public IEnumerable <object> GetUniqueKeys(DataAxis axis, int groupDescriptionIndex) { throw new NotImplementedException(); }
internal override bool Filter(IGroup group, IAggregateResultProvider results, DataAxis axis) { if (this.FilterImpl != null) { return(this.FilterImpl.PassesFilter(group)); } return(true); }
private void TestHelper(int level, DataAxis axis, SortOrder sortOrder) { var groups = GetGroupsAtLevel(axis, level); Assert.IsNotNull(groups); Assert.IsTrue(groups.Count > 0); CollectionAssert.AllItemsAreNotNull(groups); CollectionAssert.AllItemsAreUnique(groups); var comparer = new GroupComparerDecorator(this.grandTotalComparer, sortOrder, resultProvider, axis); if (level > 1) { var subGroups = GetGroupsAtLevel(axis, level - 1); foreach (var group in subGroups.OfType <Group>()) { group.SortSubGroups(comparer); IGroup temp = null; foreach (var subGroup in group.Items.OfType <IGroup>()) { if (temp != null) { int result = grandTotalComparer.CompareGroups(resultProvider, temp, subGroup, axis); if (sortOrder == SortOrder.Ascending) { Assert.IsTrue(result <= 0); } else { Assert.IsTrue(result >= 0); } } temp = subGroup; } } } else { groups.Sort(comparer); IGroup temp = null; foreach (var group in groups) { if (temp != null) { int result = grandTotalComparer.CompareGroups(resultProvider, temp, group, axis); if (sortOrder == SortOrder.Ascending) { Assert.IsTrue(result <= 0); } else { Assert.IsTrue(result >= 0); } } temp = group; } } }
/// <summary> /// Compares two <see cref="IGroup"/>s based on the current aggregate results. /// </summary> /// <param name="results">The current aggregate results.</param> /// <param name="left">The first <see cref="IGroup"/> to compare.</param> /// <param name="right">The second <see cref="IGroup"/> to compare.</param> /// <param name="axis">Identifies if the groups are in <see cref="DataAxis.Rows"/> or <see cref="DataAxis.Columns"/>.</param> /// <returns> /// A signed integer that indicates the relative values of x and y, as shown in the following table. /// <para>Value Meaning Less than zero x is less than y.</para> /// <para>Zero x equals y.</para> /// <para>Greater than zero x is greater than y.</para> /// </returns> public abstract int CompareGroups(IAggregateResultProvider results, IGroup left, IGroup right, DataAxis axis);
/// <summary> /// Adds detailed information about a supplied axis to the supplied TreeViewItem /// </summary> /// <param name="parent">Item TreeViewItem that will be the parent item to get the detail for the selected axis.</param> /// <param name="curAxis">The DataAxis we're going to be providing detail about</param> /// <param name="units">The units (if any) the current axis uses, like meters or degrees or whatnot</param> /// <returns></returns> private TreeViewItem AddAxisDetail(TreeViewItem parent, DataAxis curAxis, string units) { TreeViewItem newItem, axisDetail; int lowIndex, highIndex; newItem = AddSubItem(parent, curAxis.Name + " Axis [" + curAxis.Length + "]"); newItem.IsExpanded = true; lowIndex = highIndex = -1; lowIndex = 0; highIndex = curAxis.Length - 1; AddSubItem(newItem, "Minimum value: " + curAxis.Map[lowIndex].Value + " " + units); AddSubItem(newItem, "Maximum value: " + curAxis.Map[highIndex].Value + " " + units); axisDetail = AddSubItem(newItem, "Detail"); for (int j = lowIndex; j <= highIndex; j++) AddSubItem(axisDetail, "[" + curAxis.Map[j].Index + "] = " + curAxis.Map[j].Value.ToString() + " " + units); return newItem; }
// TODO: Currently we are using the IGroup.Names as IComparables. Should we add IComparer? /// <summary> /// Compares two <see cref="IGroup"/>s based on their <see cref="IGroup.Name"/>s. /// </summary> /// <param name="results">The current aggregate results.</param> /// <param name="left">The first <see cref="IGroup"/> to compare.</param> /// <param name="right">The second <see cref="IGroup"/> to compare.</param> /// <param name="axis">Identifies if the groups are in <see cref="DataAxis.Rows"/> or <see cref="DataAxis.Columns"/>.</param> /// <returns> /// A signed integer that indicates the relative values of x and y, as shown in the following table. /// <para>Value Meaning Less than zero x is less than y.</para> /// <para>Zero x equals y.</para> /// <para>Greater than zero x is greater than y.</para> /// </returns> public override int CompareGroups(IAggregateResultProvider results, IGroup left, IGroup right, DataAxis axis) { if (left.Name == NullValue.Instance && right.Name == NullValue.Instance) { return(0); } else if (left.Name == NullValue.Instance) { return(1); } else if (right.Name == NullValue.Instance) { return(-1); } IComparable leftComparable = left.Name as IComparable; if (leftComparable != null) { return(leftComparable.CompareTo(right.Name)); } IComparable rightComparable = right.Name as IComparable; if (rightComparable != null) { return(-rightComparable.CompareTo(left.Name)); } return(0); }
/// <summary> /// Identifies if a group should be filtered or not. /// </summary> /// <param name="group">The group.</param> /// <param name="results">Results for the current grouping. Could be used for totals lookup.</param> /// <param name="axis">Identifies if the <paramref name="group"/> is positioned in the <see cref="DataAxis.Rows"/> or <see cref="DataAxis.Columns"/>.</param> /// <returns>True if the group should be preserved, False if the group should be removed.</returns> internal abstract bool Filter(IGroup group, IAggregateResultProvider results, DataAxis axis);