organicmaps/organicmaps-tmp
Archived
13
Fork 1
Code Issues 2.7k Pull requests 182 Projects Releases 65 Wiki Activity Actions

SortUnique refactoring.

Browse source
This commit is contained in:
Vladimir Byko-Ianko 2016-05-26 13:49:01 +03:00
parent 36c26c6389
commit e060fd2fa6
2 changed files with 32 additions and 30 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

45
base/base_tests/stl_helpers_test.cpp
View file

@ -83,26 +83,35 @@ UNIT_TEST(SortUnique)
TEST_EQUAL(v, expected, ());
}
UNIT_TEST(SortUniquePred)
UNIT_TEST(SortUniqueCompPredTest1)
{
struct Foo
{
int i, j;
};
using TValue = int;
using TPair = pair<TValue, int>;
vector<TPair> v =
{{1, 22}, {2, 33}, {1, 23}, {4, 54}, {3, 34}, {5, 23}, {2, 23}, {7, 32}, {1, 12}};
vector<Foo> v = {{1, 22}, {2, 33}, {1, 23}, {4, 54}, {3, 34}, {5, 23}, {2, 23}, {7, 32}, {1, 12}};
my::SortUnique<Foo>([](Foo const & f1, Foo const & f2)
{
return f1.i < f2.i;
},
v);
my::SortUnique<TPair>(v, my::CompareBy(&TPair::first),
[](TPair const & p1, TPair const & p2) { return p1.first == p2.first; });
TEST_EQUAL(v.size(), 6, ());
TEST_EQUAL(v[0].i, 1, ());
TEST_EQUAL(v[1].i, 2, ());
TEST_EQUAL(v[2].i, 3, ());
TEST_EQUAL(v[3].i, 4, ());
TEST_EQUAL(v[4].i, 5, ());
TEST_EQUAL(v[5].i, 7, ());
vector<TValue> const expected = {1, 2, 3, 4, 5, 7};
TEST_EQUAL(v.size(), expected.size(), ());
for (int i = 0; i < v.size(); ++i)
TEST_EQUAL(v[i].first, expected[i], (i));
}
UNIT_TEST(SortUniqueCompPredTest2)
{
using TValue = double;
using TPair = pair<TValue, int>;
vector<TPair> v =
{{0.5, 11}, {1000.99, 234}, {0.5, 23}, {1234.56789, 54}, {1000.99, 34}};
my::SortUnique<TPair>(v, my::CompareBy(&TPair::first),
[](TPair const & p1, TPair const & p2) { return p1.first == p2.first; });
vector<TValue> const expected = {0.5, 1000.99, 1234.56789};
TEST_EQUAL(v.size(), expected.size(), ());
for (int i = 0; i < v.size(); ++i)
TEST_EQUAL(v[i].first, expected[i], (i));
}
} // namespace

17
base/stl_helpers.hpp
View file

@ -86,20 +86,13 @@ void SortUnique(vector<T> & v)
v.erase(unique(v.begin(), v.end()), v.end());
}
// Sorts and removes duplicate entries from |v| according to |comp|.
// Note. If several entries are equivalent according to |comp| an arbitrary entry of them
// is left in |v| after a call of this method.
// Note. |comp| should implement operator<. It means the expression
// !comp(t1, t2) && !comp(t2, t1) should return true iff t1 is equivalent to t2.
// It's necessary for std::unique.
template <typename T>
void SortUnique(function<bool(T const &, T const &)> const & comp, vector<T> & v)
// Sorts according to |comp| and removes duplicate entries according to |pred| from |v|.
// Note. If several entries are equal according to |pred| an arbitrary entry of them
// is left in |v| after a call of this function.
template <typename T, typename TComp, typename TPred>
void SortUnique(vector<T> & v, TComp && comp, TPred && pred)
{
sort(v.begin(), v.end(), comp);
function<bool(T const &, T const &)> const pred = [&comp](T const & t1, T const & t2)
{
return !comp(t1, t2) && !comp(t2, t1);
};
v.erase(unique(v.begin(), v.end(), pred), v.end());
}