From 33d8f4a62ccd328bc12f71469015045d9316ffb9 Mon Sep 17 00:00:00 2001 From: YoshiRulz Date: Tue, 7 Jul 2020 17:48:57 +1000 Subject: [PATCH] Add RigidMultiPredicateSort to replace some .ThenBy() boilerplate As documented, the class "Sorts using a single primary predicate, with subsorts using the remaining predicates in order." So only the most recent column-header-click is taken into account. I've got a WIP class in #if false for providing the "remember which column headers I clicked and in which order" behaviour, but it doesn't look like that behaviour actually exists in the codebase? --- src/BizHawk.Client.Common/tools/CheatList.cs | 61 ++++---------- src/BizHawk.Client.EmuHawk/movie/PlayMovie.cs | 42 +++------- src/BizHawk.Common/MultiPredicateSort.cs | 84 +++++++++++++++++++ .../MultiPredicateSortTests.cs | 59 +++++++++++++ 4 files changed, 169 insertions(+), 77 deletions(-) create mode 100644 src/BizHawk.Common/MultiPredicateSort.cs create mode 100644 src/BizHawk.Tests/Common/MultiPredicateSort/MultiPredicateSortTests.cs diff --git a/src/BizHawk.Client.Common/tools/CheatList.cs b/src/BizHawk.Client.Common/tools/CheatList.cs index 3abad59706..b1c6017ee6 100644 --- a/src/BizHawk.Client.Common/tools/CheatList.cs +++ b/src/BizHawk.Client.Common/tools/CheatList.cs @@ -6,7 +6,7 @@ using System.IO; using System.Linq; using System.Text; -using BizHawk.Common.CollectionExtensions; +using BizHawk.Common; using BizHawk.Emulation.Common; namespace BizHawk.Client.Common @@ -414,51 +414,22 @@ namespace BizHawk.Client.Common return true; } - public void Sort(string column, bool reverse) - { - _cheatList = column switch + private static readonly RigidMultiPredicateSort ColumnSorts + = new RigidMultiPredicateSort(new Dictionary> { - NameColumn => _cheatList.OrderBy(c => c.Name, reverse) - .ThenBy(c => c.Address ?? 0) - .ToList(), - AddressColumn => _cheatList.OrderBy(c => c.Address ?? 0, reverse) - .ThenBy(c => c.Name) - .ToList(), - ValueColumn => _cheatList.OrderBy(c => c.Value ?? 0, reverse) - .ThenBy(c => c.Name) - .ThenBy(c => c.Address ?? 0) - .ToList(), - CompareColumn => _cheatList.OrderBy(c => c.Compare ?? 0, reverse) - .ThenBy(c => c.Name) - .ThenBy(c => c.Address ?? 0) - .ToList(), - OnColumn => _cheatList.OrderBy(c => c.Enabled, reverse) - .ThenBy(c => c.Name) - .ThenBy(c => c.Address ?? 0) - .ToList(), - DomainColumn => _cheatList.OrderBy(c => c.Domain, reverse) - .ThenBy(c => c.Name) - .ThenBy(c => c.Address ?? 0) - .ToList(), - SizeColumn => _cheatList.OrderBy(c => (int) c.Size, reverse) - .ThenBy(c => c.Name) - .ThenBy(c => c.Address ?? 0) - .ToList(), - EndianColumn => _cheatList.OrderBy(c => c.BigEndian, reverse) - .ThenBy(c => c.Name) - .ThenBy(c => c.Address ?? 0) - .ToList(), - TypeColumn => _cheatList.OrderBy(c => c.Type, reverse) - .ThenBy(c => c.Name) - .ThenBy(c => c.Address ?? 0) - .ToList(), - ComparisonType => _cheatList.OrderBy(c => c.ComparisonType, reverse) - .ThenBy(c => c.Name) - .ThenBy(c => c.Address ?? 0) - .ToList(), - _ => _cheatList - }; - } + [NameColumn] = c => c.Name, + [AddressColumn] = c => c.Address ?? 0L, + [ValueColumn] = c => c.Value ?? 0, + [CompareColumn] = c => c.Compare ?? 0, + [OnColumn] = c => c.Enabled, + [DomainColumn] = c => c.Domain.Name, + [SizeColumn] = c => (int) c.Size, + [EndianColumn] = c => c.BigEndian, + [TypeColumn] = c => c.Type, + [ComparisonType] = c => c.ComparisonType + }); + + public void Sort(string column, bool reverse) => _cheatList = ColumnSorts.AppliedTo(_cheatList, column, firstIsDesc: reverse); public void SetDefaultFileName(string defaultFileName) { diff --git a/src/BizHawk.Client.EmuHawk/movie/PlayMovie.cs b/src/BizHawk.Client.EmuHawk/movie/PlayMovie.cs index 929bbcda5e..a117c9b969 100644 --- a/src/BizHawk.Client.EmuHawk/movie/PlayMovie.cs +++ b/src/BizHawk.Client.EmuHawk/movie/PlayMovie.cs @@ -342,41 +342,19 @@ namespace BizHawk.Client.EmuHawk Close(); } + private static readonly RigidMultiPredicateSort ColumnSorts + = new RigidMultiPredicateSort(new Dictionary> + { + ["File"] = x => Path.GetFileName(x.Filename), + ["SysID"] = x => x.SystemID, + ["Game"] = x => x.GameName, + ["Length (est.)"] = x => x.FrameCount + }); + private void MovieView_ColumnClick(object sender, ColumnClickEventArgs e) { var columnName = MovieView.Columns[e.Column].Text; - switch (columnName) - { - case "File": - default: - _movieList = _movieList.OrderBy(x => Path.GetFileName(x.Filename)) - .ThenBy(x => x.SystemID) - .ThenBy(x => x.GameName) - .ThenBy(x => x.FrameCount) - .ToList(); - break; - case "SysID": - _movieList = _movieList.OrderBy(x => x.SystemID) - .ThenBy(x => Path.GetFileName(x.Filename)) - .ThenBy(x => x.GameName) - .ThenBy(x => x.FrameCount) - .ToList(); - break; - case "Game": - _movieList = _movieList.OrderBy(x => x.GameName) - .ThenBy(x => Path.GetFileName(x.Filename)) - .ThenBy(x => x.SystemID) - .ThenBy(x => x.FrameCount) - .ToList(); - break; - case "Length (est.)": - _movieList = _movieList.OrderBy(x => x.FrameCount) - .ThenBy(x => Path.GetFileName(x.Filename)) - .ThenBy(x => x.SystemID) - .ThenBy(x => x.GameName) - .ToList(); - break; - } + _movieList = ColumnSorts.AppliedTo(_movieList, columnName); if (_sortedCol == columnName && _sortReverse) { _movieList.Reverse(); diff --git a/src/BizHawk.Common/MultiPredicateSort.cs b/src/BizHawk.Common/MultiPredicateSort.cs new file mode 100644 index 0000000000..dfeb5ea612 --- /dev/null +++ b/src/BizHawk.Common/MultiPredicateSort.cs @@ -0,0 +1,84 @@ +using System; +using System.Collections.Generic; +using System.Linq; + +namespace BizHawk.Common +{ +#if false + /// Sorts using a reorderable list of predicates. + /// + public sealed class MultiPredicateSort + { + private readonly int _count; + + /// TODO would an array be faster? + private readonly List<(string ID, bool IsDesc)> _order; + + private readonly IReadOnlyDictionary> _predicates; + + public MultiPredicateSort(IReadOnlyDictionary> predicates) + { + _count = predicates.Count; + if (_count == 0) throw new ArgumentException("must have at least 1 predicate", nameof(predicates)); + _order = predicates.Select(kvp => (kvp.Key, false)).ToList(); + _predicates = predicates; + } + + public List AppliedTo(IReadOnlyCollection list) + { + var temp = _order[0].IsDesc + ? list.OrderByDescending(_predicates[_order[0].ID]) + : list.OrderBy(_predicates[_order[0].ID]); + for (var i = 1; i < _count; i++) + { + temp = _order[i].IsDesc + ? temp.ThenByDescending(_predicates[_order[i].ID]) + : temp.ThenBy(_predicates[_order[i].ID]); + } + return temp.ToList(); + } + } +#endif + + /// Sorts using a single primary predicate, with subsorts using the remaining predicates in order. +#if false + /// +#endif + public sealed class RigidMultiPredicateSort + { + private readonly IReadOnlyDictionary> _predicates; + + public RigidMultiPredicateSort(IReadOnlyDictionary> predicates) + { + if (predicates.Count == 0) throw new ArgumentException("must have at least 1 predicate", nameof(predicates)); + _predicates = predicates; + } + + /// sorts using asc/desc (by ), then by the remaining predicates, all asc + public List AppliedTo(IReadOnlyCollection list, string idOfFirst, bool firstIsDesc = false) + { + var temp = firstIsDesc + ? list.OrderByDescending(_predicates[idOfFirst]) + : list.OrderBy(_predicates[idOfFirst]); + foreach (var kvp in _predicates) + { + if (kvp.Key == idOfFirst) continue; + temp = temp.ThenBy(kvp.Value); + } + return temp.ToList(); + } + + public List AppliedTo(IReadOnlyCollection list, string idOfFirst, IReadOnlyDictionary isDescMap) + { + var temp = isDescMap[idOfFirst] + ? list.OrderByDescending(_predicates[idOfFirst]) + : list.OrderBy(_predicates[idOfFirst]); + foreach (var kvp in _predicates) + { + if (kvp.Key == idOfFirst) continue; + temp = isDescMap[kvp.Key] ? temp.ThenByDescending(kvp.Value) : temp.ThenBy(kvp.Value); + } + return temp.ToList(); + } + } +} diff --git a/src/BizHawk.Tests/Common/MultiPredicateSort/MultiPredicateSortTests.cs b/src/BizHawk.Tests/Common/MultiPredicateSort/MultiPredicateSortTests.cs new file mode 100644 index 0000000000..6307b8c20c --- /dev/null +++ b/src/BizHawk.Tests/Common/MultiPredicateSort/MultiPredicateSortTests.cs @@ -0,0 +1,59 @@ +using System; +using System.Collections.Generic; +using System.Linq; + +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace BizHawk.Common.Tests.Common.MultiPredicateSort +{ + [TestClass] + public class MultiPredicateSortTests + { + private static readonly (int X, string Y)[] Unsorted = { (1, "b"), (2, "a"), (2, "b"), (1, "a") }; + + private static readonly (int X, string Y)[] SortedByXThenYDesc = { (1, "b"), (1, "a"), (2, "b"), (2, "a") }; + + private static readonly (int X, string Y)[] SortedByYDescThenXDesc = { (2, "b"), (1, "b"), (2, "a"), (1, "a") }; + + private static void AssertSequenceEqual(IEnumerable expected, IEnumerable actual) => Assert.IsTrue(expected.SequenceEqual(actual)); + + [TestMethod] + public void SanityCheck() + { + AssertSequenceEqual( + SortedByYDescThenXDesc, + Unsorted.OrderByDescending(t => t.Y).ThenByDescending(t => t.X) + ); + AssertSequenceEqual( + SortedByYDescThenXDesc, + Unsorted.OrderByDescending(t => t.X).OrderByDescending(t => t.Y) + ); + } + + [TestMethod] + public void TestRigidSort() + { + var sorts = new RigidMultiPredicateSort<(int X, string Y)>(new Dictionary> + { + ["by_x"] = t => t.X, + ["by_y"] = t => t.Y + }); + AssertSequenceEqual( + SortedByXThenYDesc, + sorts.AppliedTo( + Unsorted, + "by_x", + new Dictionary { ["by_x"] = false, ["by_y"] = true } + ) + ); + AssertSequenceEqual( + SortedByYDescThenXDesc, + sorts.AppliedTo( + Unsorted, + "by_y", + new Dictionary { ["by_x"] = true, ["by_y"] = true } + ) + ); + } + } +}