add unique_ref::operators < and ==

Author: igagis

src/utki/unique_ref.hpp

@@ -69,10 +69,13 @@ class unique_ref
 	 *              Must not be null, otherwise it causes undefined behaviour.
 	 */
 	explicit unique_ref(std::unique_ptr<object_type> ptr) :
-		p(std::move(ptr)){ASSERT(this->p)}
+		p(std::move(ptr))
+	{
+		utki::assert(this->p, SL);
+	}
 
-		// there should be no default constructor, as unique_ref cannot be nullptr
-		unique_ref() = delete;
+	// there should be no default constructor, as unique_ref cannot be nullptr
+	unique_ref() = delete;
 
 	unique_ref(const unique_ref&) = delete;
 	unique_ref& operator=(const unique_ref&) = delete;
@@ -96,7 +99,7 @@ class unique_ref
 	unique_ref(unique_ref<other_object_type>&& sr) noexcept :
 		p(std::move(sr.p))
 	{
-		ASSERT(this->p)
+		utki::assert(this->p, SL);
 	}
 
 	/**
@@ -106,7 +109,7 @@ class unique_ref
 	 */
 	constexpr object_type& get() const noexcept
 	{
-		ASSERT(this->p)
+		utki::assert(this->p, SL);
 		return *this->p;
 	}
 
@@ -118,6 +121,49 @@ class unique_ref
 	{
 		return this->get();
 	}
+
+	/**
+	 * @brief Less-than operator for comparison with another object.
+	 * Needed for using unique_ref in ordered containers (e.g. std::set).
+	 * Effecively calls opearator<() of the pointed-to object.
+	 * @return true if this object is less than the other object.
+	 * @return false otherwise.
+	 */
+	friend constexpr bool operator<(const unique_ref& r, const object_type& o) noexcept
+	{
+		return r.get() < o;
+	}
+
+	/**
+	 * @brief Equality operator for comparison with another object.
+	 * Needed for using unique_ref in ordered containers (e.g. std::set).
+	 * Effectively calls operator==() of the pointed-to object.
+	 * @param r - left hand side of the operator.
+	 * @param o - right hand side of the operator.
+	 * @return true if this object is equal to the other object.
+	 * @return false otherwise.
+	 */
+	friend constexpr bool operator==(const unique_ref& r, const object_type& o) noexcept
+	{
+		return r.get() == o;
+	}
+
+	/**
+	 * @brief Equality operator for comparison with another object.
+	 * Needed for using unique_ref in ordered containers (e.g. std::set).
+	 * Effectively calls operator==() of the pointed-to object.
+	 * @param l - left hand side of the operator.
+	 * @param r - right hand side of the operator.
+	 * @return true if this object is equal to the other object.
+	 * @return false otherwise.
+	 */
+	friend constexpr bool operator==(
+		const unique_ref& l, //
+		const unique_ref& r
+	) noexcept
+	{
+		return l.get() == r.get();
+	}
 };
 
 /**

tests/unit/src/unique_ref.cpp

@@ -1,8 +1,10 @@
 #include <algorithm>
+#include <set>
 
 #include <tst/check.hpp>
 #include <tst/set.hpp>
 #include <utki/unique_ref.hpp>
+#include <utki/utility.hpp>
 
 namespace {
 const std::string etalon = "hello world!";
@@ -21,6 +23,16 @@ struct a0 {
 	a0& operator=(a0&&) = default;
 
 	virtual ~a0() = default;
+
+	bool operator<(const a0& r) const noexcept
+	{
+		return this < &r;
+	}
+
+	bool operator==(const a0& r) const noexcept
+	{
+		return this == &r;
+	}
 };
 
 struct a1 : public a0 {
@@ -165,5 +177,32 @@ const tst::set set("unique_ref", [](tst::suite& suite) {
 		tst::check_eq(vec[1].get().a_0, 3, SL);
 		tst::check_eq(vec[2].get().a_0, 1, SL);
 	});
+
+	suite.add("use_with_std_set", []() {
+		std::set<utki::unique_ref<a0>> set;
+
+		auto v1 = utki::make_unique<a0>(1);
+		auto v2 = utki::make_unique<a0>(2);
+		auto v3 = utki::make_unique<a0>(3);
+
+		auto& v1r = v1.get();
+		auto& v2r = v2.get();
+		auto& v3r = v3.get();
+
+		set.insert(std::move(v1));
+		set.insert(std::move(v2));
+
+		tst::check_eq(set.size(), size_t(2), SL);
+
+		for(auto& v : set) {
+			tst::check(v.get().a_0 == 1 || v.get().a_0 == 2, SL);
+		}
+
+		tst::check(!utki::contains(set, v3), SL);
+
+		tst::check(utki::contains(set, v1r), SL);
+		tst::check(utki::contains(set, v2r), SL);
+		tst::check(!utki::contains(set, v3r), SL);
+	});
 });
 } // namespace