Merge pull request #1189 from igchor/exceptions_generic2

Make exception_with_errormsg take arbitrary num of params

Author: lukaszstolarczuk

include/libpmemobj++/condition_variable.hpp

@@ -73,10 +73,9 @@ class condition_variable {
 	{
 		PMEMobjpool *pop = pmemobj_pool_by_ptr(this);
 		if (int ret = pmemobj_cond_signal(pop, &this->pcond))
-			throw pmem::lock_error(
+			throw detail::exception_with_errormsg<lock_error>(
 				ret, std::system_category(),
-				"Error notifying one on a condition variable.")
-				.with_pmemobj_errormsg();
+				"Error notifying one on a condition variable.");
 	}
 
 	/**
@@ -89,10 +88,9 @@ class condition_variable {
 	{
 		PMEMobjpool *pop = pmemobj_pool_by_ptr(this);
 		if (int ret = pmemobj_cond_broadcast(pop, &this->pcond))
-			throw pmem::lock_error(
+			throw detail::exception_with_errormsg<lock_error>(
 				ret, std::system_category(),
-				"Error notifying all on a condition variable.")
-				.with_pmemobj_errormsg();
+				"Error notifying all on a condition variable.");
 	}
 
 	/**
@@ -479,10 +477,9 @@ class condition_variable {
 		PMEMobjpool *pop = pmemobj_pool_by_ptr(this);
 		if (int ret = pmemobj_cond_wait(pop, &this->pcond,
 						lock.native_handle()))
-			throw pmem::lock_error(
+			throw detail::exception_with_errormsg<lock_error>(
 				ret, std::system_category(),
-				"Error waiting on a condition variable.")
-				.with_pmemobj_errormsg();
+				"Error waiting on a condition variable.");
 	}
 
 	/**
@@ -523,10 +520,9 @@ class condition_variable {
 		else if (ret == ETIMEDOUT)
 			return std::cv_status::timeout;
 		else
-			throw pmem::lock_error(
+			throw detail::exception_with_errormsg<lock_error>(
 				ret, std::system_category(),
-				"Error waiting on a condition variable.")
-				.with_pmemobj_errormsg();
+				"Error waiting on a condition variable.");
 	}
 
 	/**

include/libpmemobj++/detail/common.hpp

@@ -159,16 +159,6 @@ static constexpr size_t CACHELINE_SIZE = 128ULL;
 #error unable to recognize architecture at compile time
 #endif
 
-/**
- * Generic error message decorator for pmemobj-based exceptions.
- */
-template <class ExcT, typename MsgT>
-ExcT
-exception_with_errormsg(const MsgT &msg)
-{
-	return ExcT(msg + std::string(": ") + detail::errormsg());
-}
-
 /**
  * Conditionally add 'count' objects to a transaction.
  *

include/libpmemobj++/mutex.hpp

@@ -71,9 +71,9 @@ class mutex {
 	{
 		PMEMobjpool *pop = pmemobj_pool_by_ptr(this);
 		if (int ret = pmemobj_mutex_lock(pop, &this->plock))
-			throw pmem::lock_error(ret, std::system_category(),
-					       "Failed to lock a mutex.")
-				.with_pmemobj_errormsg();
+			throw detail::exception_with_errormsg<lock_error>(
+				ret, std::system_category(),
+				"Failed to lock a mutex.");
 	}
 
 	/**
@@ -101,9 +101,9 @@ class mutex {
 		else if (ret == EBUSY)
 			return false;
 		else
-			throw pmem::lock_error(ret, std::system_category(),
-					       "Failed to lock a mutex.")
-				.with_pmemobj_errormsg();
+			throw detail::exception_with_errormsg<lock_error>(
+				ret, std::system_category(),
+				"Failed to lock a mutex.");
 	}
 
 	/**
@@ -119,9 +119,9 @@ class mutex {
 		PMEMobjpool *pop = pmemobj_pool_by_ptr(this);
 		int ret = pmemobj_mutex_unlock(pop, &this->plock);
 		if (ret)
-			throw pmem::lock_error(ret, std::system_category(),
-					       "Failed to unlock a mutex.")
-				.with_pmemobj_errormsg();
+			throw detail::exception_with_errormsg<lock_error>(
+				ret, std::system_category(),
+				"Failed to unlock a mutex.");
 	}
 
 	/**

include/libpmemobj++/pexceptions.hpp

@@ -12,10 +12,13 @@
 #include <stdexcept>
 #include <string>
 #include <system_error>
+#include <tuple>
 
 #include <libpmemobj/atomic_base.h>
 #include <libpmemobj/base.h>
 
+#include <libpmemobj++/detail/integer_sequence.hpp>
+
 namespace pmem
 {
 
@@ -34,6 +37,41 @@ errormsg(void)
 	return std::string(pmemobj_errormsg());
 #endif
 }
+
+/**
+ * Helper for exception_with_errormsg.
+ *
+ * Accepts tuple with arguments and index_sequence which correspond
+ * to all but last argument. The last element in tuple is assumed to
+ * be an error message. Before passing it to ExcT constructor it is merged
+ * with detail::errormsg()
+ */
+template <typename ExcT, size_t... I, typename Tuple>
+ExcT
+exception_with_errormsg_helper(index_sequence<I...>, Tuple &&args)
+{
+	static_assert(std::is_rvalue_reference<decltype(args)>::value,
+		      "args should be rvalue reference!");
+
+	auto msg = std::get<sizeof...(I)>(std::move(args)) + std::string(": ") +
+		detail::errormsg();
+	return ExcT(std::get<I>(std::move(args))..., std::move(msg));
+}
+
+/**
+ * Generic error message decorator for pmemobj-based exceptions.
+ *
+ * It accepts arbitrary number of parameters. The last parameter must be an
+ * error message.
+ */
+template <class ExcT, typename... Args>
+ExcT
+exception_with_errormsg(Args &&... args)
+{
+	return exception_with_errormsg_helper<ExcT>(
+		make_index_sequence<sizeof...(Args) - 1>{},
+		std::forward_as_tuple(std::forward<Args>(args)...));
+}
 } /* namespace detail */
 
 /**
@@ -80,19 +118,6 @@ class transaction_error : public std::runtime_error {
 class lock_error : public std::system_error {
 public:
 	using std::system_error::system_error;
-
-	/**
-	 * Retrieves last error message from libpmemobj
-	 * and adds it to the current error.
-	 */
-	lock_error &
-	with_pmemobj_errormsg()
-	{
-		(*this) = lock_error(code(),
-				     what() + std::string(": ") +
-					     detail::errormsg());
-		return *this;
-	}
 };
 
 /**
@@ -196,18 +221,6 @@ class defrag_error : public std::runtime_error {
 	{
 	}
 
-	/**
-	 * Append partial results.
-	 *
-	 * @param result potential partial results of the defragmentation
-	 */
-	defrag_error &
-	append_result(pobj_defrag_result result)
-	{
-		this->result = result;
-		return *this;
-	}
-
 	/**
 	 * Results of the defragmentation run.
 	 *

include/libpmemobj++/pool.hpp

@@ -425,8 +425,7 @@ class pool_base {
 
 		if (ret != 0)
 			throw detail::exception_with_errormsg<defrag_error>(
-				"Defragmentation failed")
-				.append_result(result);
+				result, "Defragmentation failed");
 		return result;
 	}
 

include/libpmemobj++/shared_mutex.hpp

@@ -72,9 +72,9 @@ class shared_mutex {
 	{
 		PMEMobjpool *pop = pmemobj_pool_by_ptr(this);
 		if (int ret = pmemobj_rwlock_wrlock(pop, &this->plock))
-			throw pmem::lock_error(ret, std::system_category(),
-					       "Failed to lock a shared mutex.")
-				.with_pmemobj_errormsg();
+			throw detail::exception_with_errormsg<lock_error>(
+				ret, std::system_category(),
+				"Failed to lock a shared mutex.");
 	}
 
 	/**
@@ -97,7 +97,7 @@ class shared_mutex {
 	{
 		PMEMobjpool *pop = pmemobj_pool_by_ptr(this);
 		if (int ret = pmemobj_rwlock_rdlock(pop, &this->plock))
-			throw pmem::lock_error(
+			throw detail::exception_with_errormsg<lock_error>(
 				ret, std::system_category(),
 				"Failed to shared lock a shared mutex.");
 	}
@@ -127,9 +127,9 @@ class shared_mutex {
 		else if (ret == EBUSY)
 			return false;
 		else
-			throw pmem::lock_error(ret, std::system_category(),
-					       "Failed to lock a shared mutex.")
-				.with_pmemobj_errormsg();
+			throw detail::exception_with_errormsg<lock_error>(
+				ret, std::system_category(),
+				"Failed to lock a shared mutex.");
 	}
 
 	/**
@@ -159,9 +159,9 @@ class shared_mutex {
 		else if (ret == EBUSY)
 			return false;
 		else
-			throw pmem::lock_error(ret, std::system_category(),
-					       "Failed to lock a shared mutex.")
-				.with_pmemobj_errormsg();
+			throw detail::exception_with_errormsg<lock_error>(
+				ret, std::system_category(),
+				"Failed to lock a shared mutex.");
 	}
 
 	/**
@@ -176,10 +176,9 @@ class shared_mutex {
 		PMEMobjpool *pop = pmemobj_pool_by_ptr(this);
 		int ret = pmemobj_rwlock_unlock(pop, &this->plock);
 		if (ret)
-			throw pmem::lock_error(
+			throw detail::exception_with_errormsg<lock_error>(
 				ret, std::system_category(),
-				"Failed to unlock a shared mutex.")
-				.with_pmemobj_errormsg();
+				"Failed to unlock a shared mutex.");
 	}
 
 	/**

include/libpmemobj++/timed_mutex.hpp

@@ -74,9 +74,9 @@ class timed_mutex {
 	{
 		PMEMobjpool *pop = pmemobj_pool_by_ptr(this);
 		if (int ret = pmemobj_mutex_lock(pop, &this->plock))
-			throw pmem::lock_error(ret, std::system_category(),
-					       "Failed to lock a mutex.")
-				.with_pmemobj_errormsg();
+			throw detail::exception_with_errormsg<lock_error>(
+				ret, std::system_category(),
+				"Failed to lock a mutex.");
 	}
 
 	/**
@@ -104,9 +104,9 @@ class timed_mutex {
 		else if (ret == EBUSY)
 			return false;
 		else
-			throw pmem::lock_error(ret, std::system_category(),
-					       "Failed to lock a mutex.")
-				.with_pmemobj_errormsg();
+			throw detail::exception_with_errormsg<lock_error>(
+				ret, std::system_category(),
+				"Failed to lock a mutex.");
 	}
 
 	/**
@@ -171,9 +171,9 @@ class timed_mutex {
 		PMEMobjpool *pop = pmemobj_pool_by_ptr(this);
 		int ret = pmemobj_mutex_unlock(pop, &this->plock);
 		if (ret)
-			throw pmem::lock_error(ret, std::system_category(),
-					       "Failed to unlock a mutex.")
-				.with_pmemobj_errormsg();
+			throw detail::exception_with_errormsg<lock_error>(
+				ret, std::system_category(),
+				"Failed to unlock a mutex.");
 	}
 
 	/**
@@ -222,8 +222,9 @@ class timed_mutex {
 		else if (ret == ETIMEDOUT)
 			return false;
 		else
-			throw pmem::lock_error(ret, std::system_category(),
-					       "Failed to lock a mutex");
+			throw detail::exception_with_errormsg<lock_error>(
+				ret, std::system_category(),
+				"Failed to lock a mutex");
 	}
 
 	/** A POSIX style PMEM-resident timed_mutex.*/