Make disjoint set datastructure templatized over value type

with explicit instantiation

Author: clonker

libsolutil/DisjointSet.cpp

@@ -24,7 +24,8 @@
 
 using namespace solidity::util;
 
-ContiguousDisjointSet::ContiguousDisjointSet(size_t const _numNodes):
+template<typename ValueType>
+ContiguousDisjointSet<ValueType>::ContiguousDisjointSet(size_t const _numNodes):
 	m_parents(_numNodes),
 	m_neighbors(_numNodes),
 	m_sizes(_numNodes, static_cast<value_type>(1)),
@@ -35,9 +36,11 @@ ContiguousDisjointSet::ContiguousDisjointSet(size_t const _numNodes):
 	std::iota(m_neighbors.begin(), m_neighbors.end(), 0);
 }
 
-size_t ContiguousDisjointSet::numSets() const { return m_numSets; }
+template<typename ValueType>
+size_t ContiguousDisjointSet<ValueType>::numSets() const { return m_numSets; }
 
-ContiguousDisjointSet::value_type ContiguousDisjointSet::find(value_type const _element) const
+template<typename ValueType>
+typename ContiguousDisjointSet<ValueType>::value_type ContiguousDisjointSet<ValueType>::find(value_type const _element) const
 {
 	solAssert(_element < m_parents.size());
 	// path halving
@@ -50,7 +53,8 @@ ContiguousDisjointSet::value_type ContiguousDisjointSet::find(value_type const _
 	return rootElement;
 }
 
-void ContiguousDisjointSet::merge(value_type const _x, value_type const _y, bool const _mergeBySize)
+template<typename ValueType>
+void ContiguousDisjointSet<ValueType>::merge(value_type const _x, value_type const _y, bool const _mergeBySize)
 {
 	auto xRoot = find(_x);
 	auto yRoot = find(_y);
@@ -69,17 +73,20 @@ void ContiguousDisjointSet::merge(value_type const _x, value_type const _y, bool
 	--m_numSets;
 }
 
-bool ContiguousDisjointSet::sameSubset(value_type const _x, value_type const _y) const
+template<typename ValueType>
+bool ContiguousDisjointSet<ValueType>::sameSubset(value_type const _x, value_type const _y) const
 {
 	return find(_x) == find(_y);
 }
 
-ContiguousDisjointSet::size_type ContiguousDisjointSet::sizeOfSubset(value_type const _x) const
+template<typename ValueType>
+typename  ContiguousDisjointSet<ValueType>::size_type ContiguousDisjointSet<ValueType>::sizeOfSubset(value_type const _x) const
 {
 	return m_sizes[find(_x)];
 }
 
-std::set<ContiguousDisjointSet::value_type> ContiguousDisjointSet::subset(value_type const _x) const
+template<typename ValueType>
+std::set<typename ContiguousDisjointSet<ValueType>::value_type> ContiguousDisjointSet<ValueType>::subset(value_type const _x) const
 {
 	solAssert(_x < m_parents.size());
 	std::set<value_type> result{_x};
@@ -92,7 +99,8 @@ std::set<ContiguousDisjointSet::value_type> ContiguousDisjointSet::subset(value_
 	return result;
 }
 
-std::vector<std::set<ContiguousDisjointSet::value_type>> ContiguousDisjointSet::subsets() const
+template<typename ValueType>
+std::vector<std::set<typename ContiguousDisjointSet<ValueType>::value_type>> ContiguousDisjointSet<ValueType>::subsets() const
 {
 	std::vector<std::set<value_type>> result;
 	std::vector<std::uint8_t> visited(m_parents.size(), false);
@@ -107,3 +115,5 @@ std::vector<std::set<ContiguousDisjointSet::value_type>> ContiguousDisjointSet::
 	}
 	return result;
 }
+
+template class solidity::util::ContiguousDisjointSet<std::uint32_t>;

libsolutil/DisjointSet.h

@@ -31,11 +31,12 @@ namespace solidity::util
 /// [1] https://en.wikipedia.org/wiki/Disjoint-set_data_structure
 /// [2] Tarjan, Robert E., and Jan Van Leeuwen. "Worst-case analysis of set union algorithms."
 ///     Journal of the ACM (JACM) 31.2 (1984): 245-281.
+template<typename ValueType>
 class ContiguousDisjointSet
 {
 public:
 	using size_type = size_t;
-	using value_type = size_t;
+	using value_type = ValueType;
 
 	/// Constructs a new disjoint set datastructure with `_numNodes` elements and each element in its own individual set
 	explicit ContiguousDisjointSet(size_t _numNodes);

test/libsolutil/DisjointSet.cpp

@@ -29,8 +29,8 @@ BOOST_AUTO_TEST_SUITE(DisjointSetTest)
 
 BOOST_AUTO_TEST_CASE(full_union)
 {
-	ContiguousDisjointSet ds(10);
-	for (size_t i = 1; i < 10; ++i)
+	ContiguousDisjointSet<std::uint32_t> ds(10);
+	for (std::uint32_t i = 1; i < 10; ++i)
 	{
 		BOOST_CHECK(!ds.sameSubset(0, i));
 		ds.merge(0, i);
@@ -42,16 +42,16 @@ BOOST_AUTO_TEST_CASE(full_union)
 	std::set<size_t> fullSet{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 	BOOST_CHECK_EQUAL_COLLECTIONS(subsets[0].begin(), subsets[0].end(), fullSet.begin(), fullSet.end());
 
-	for (size_t i = 1; i < 10; ++i) BOOST_CHECK_EQUAL(ds.find(0), ds.find(i));
+	for (std::uint32_t i = 1; i < 10; ++i) BOOST_CHECK_EQUAL(ds.find(0), ds.find(i));
 }
 
 BOOST_AUTO_TEST_CASE(pairs)
 {
-	ContiguousDisjointSet ds(10);
+	ContiguousDisjointSet<std::uint32_t> ds(10);
 	BOOST_CHECK_EQUAL(ds.numSets(), 10);
 	BOOST_CHECK_EQUAL(ds.subsets().size(), 10);
 
-	auto const checkPair = [&](size_t expectedNumSubsets, size_t x, size_t y)
+	auto const checkPair = [&](size_t expectedNumSubsets, std::uint32_t x, std::uint32_t y)
 	{
 		BOOST_CHECK_EQUAL(ds.numSets(), expectedNumSubsets);
 		BOOST_CHECK_EQUAL(ds.subsets().size(), expectedNumSubsets);
@@ -84,7 +84,7 @@ BOOST_AUTO_TEST_CASE(pairs)
 
 BOOST_AUTO_TEST_CASE(merge_with_fixed_representative)
 {
-	ContiguousDisjointSet ds(10);
+	ContiguousDisjointSet<std::uint32_t> ds(10);
 	ds.merge(5, 3, false);
 	BOOST_CHECK_EQUAL(ds.find(5), 5);
 	ds.merge(1, 2);