X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=common%2Futility%2Fsafe_ptr.h;h=9eeb923a4a32bace6c1f4cf165e60e18ce9b8457;hb=852dacfae88898d42e79817b761f3e309a53153d;hp=9c75e3d475cb5f7c35b0962f4997ea4c724c5c58;hpb=7e5091cff2b2c2197f91eb5adb0edafdfa564069;p=casparcg

diff --git a/common/utility/safe_ptr.h b/common/utility/safe_ptr.h
index 9c75e3d47..9eeb923a4 100644
--- a/common/utility/safe_ptr.h
+++ b/common/utility/safe_ptr.h
@@ -1,10 +1,8 @@
 #pragma once
 
-#include "../exception/exceptions.h"
-
 #include <memory>
-#include <vector>
 #include <type_traits>
+#include <exception>
 
 namespace caspar {
 	
@@ -15,48 +13,69 @@ class safe_ptr
 public:
 	typedef T element_type;
 	
-	safe_ptr() : impl_(std::make_shared<T>()){static_assert(!std::is_abstract<T>::value, "Cannot construct abstract class.");}	
+	safe_ptr() : impl_(std::make_shared<T>()){}	
 	
 	safe_ptr(const safe_ptr<T>& other) : impl_(other.impl_){}
-	safe_ptr(safe_ptr&& other) : impl_(other.impl_) {} // Move doesn't move.
 	
-	template<typename Y>
-	safe_ptr(const safe_ptr<Y>& other, typename std::enable_if<std::is_convertible<Y*, T*>::value, void*>::type = 0) : impl_(other.impl_){}
+	template<typename U>
+	safe_ptr(const safe_ptr<U>& other, typename std::enable_if<std::is_convertible<U*, T*>::value, void*>::type = 0) : impl_(other.impl_){}
 		
-	template<typename Y>	
-	safe_ptr(const Y& impl, typename std::enable_if<std::is_convertible<typename std::add_pointer<Y>::type, typename std::add_pointer<T>::type>::value, void>::type* = 0)
-		: impl_(std::make_shared<Y>(impl)) {}
+	template<typename U>	
+	safe_ptr(const U& impl, typename std::enable_if<std::is_convertible<typename std::add_pointer<U>::type, typename std::add_pointer<T>::type>::value, void>::type* = 0)
+		: impl_(std::make_shared<U>(impl)) {}
 	
-	template<typename Y>	
-	safe_ptr(Y&& impl, typename std::enable_if<std::is_convertible<typename std::add_pointer<Y>::type, typename std::add_pointer<T>::type>::value, void>::type* = 0)
-		: impl_(std::make_shared<Y>(std::forward<Y>(impl))) {}
+	template<typename U, typename D>		
+	safe_ptr(const U& impl, D dtor, typename std::enable_if<std::is_convertible<typename std::add_pointer<U>::type, typename std::add_pointer<T>::type>::value, void>::type* = 0)
+		: impl_(new U(impl), dtor) {}
+
+	template<typename U>	
+	safe_ptr(U&& impl, typename std::enable_if<std::is_convertible<typename std::add_pointer<U>::type, typename std::add_pointer<T>::type>::value, void>::type* = 0)
+		: impl_(std::make_shared<U>(std::forward<U>(impl))) {}
+
+	template<typename U, typename D>	
+	safe_ptr(U&& impl, D dtor, typename std::enable_if<std::is_convertible<typename std::add_pointer<U>::type, typename std::add_pointer<T>::type>::value, void>::type* = 0)
+		: impl_(new U(std::forward<U>(impl)), dtor) {}
 			
-	template<typename Y>	
-	explicit safe_ptr(const std::shared_ptr<Y>& impl, typename std::enable_if<std::is_convertible<Y*, T*>::value, void*>::type = 0) : impl_(impl)
+	template<typename U>	
+	explicit safe_ptr(const std::shared_ptr<U>& impl, typename std::enable_if<std::is_convertible<U*, T*>::value, void*>::type = 0) : impl_(impl)
 	{
 		if(!impl_)
-			BOOST_THROW_EXCEPTION(null_argument() << msg_info("impl"));
+			throw std::invalid_argument("impl");
 	}
 	
-	template<typename Y>	
-	explicit safe_ptr(std::shared_ptr<Y>&& impl, typename std::enable_if<std::is_convertible<Y*, T*>::value, void*>::type = 0) : impl_(std::move(impl))
+	template<typename U>	
+	explicit safe_ptr(std::shared_ptr<U>&& impl, typename std::enable_if<std::is_convertible<U*, T*>::value, void*>::type = 0) : impl_(std::move(impl))
+	{
+		if(!impl_)
+			throw std::invalid_argument("impl");
+	}
+
+	template<typename U>	
+	explicit safe_ptr(U* impl, typename std::enable_if<std::is_convertible<U*, T*>::value, void*>::type = 0) : impl_(impl)
+	{
+		if(!impl_)
+			throw std::invalid_argument("impl");
+	}
+
+	template<typename U, typename D>	
+	explicit safe_ptr(U* impl, D dtor, typename std::enable_if<std::is_convertible<U*, T*>::value, void*>::type = 0) : impl_(impl, dtor)
 	{
 		if(!impl_)
-			BOOST_THROW_EXCEPTION(null_argument() << msg_info("impl"));
+			throw std::invalid_argument("impl");
 	}
 
-	template<typename Y>
-	typename std::enable_if<std::is_convertible<Y*, T*>::value, safe_ptr<T>&>::type
-	operator=(const safe_ptr<Y>& other)
+	template<typename U>
+	typename std::enable_if<std::is_convertible<U*, T*>::value, safe_ptr<T>&>::type
+	operator=(const safe_ptr<U>& other)
 	{
 		safe_ptr<T> temp(other);
 		temp.swap(*this);
 		return *this;
 	}
 
-	template <typename Y>
-	typename std::enable_if<std::is_convertible<typename std::add_pointer<Y>::type, typename std::add_pointer<T>::type>::value, safe_ptr<T>&>::type
-	operator=(Y&& impl)
+	template <typename U>
+	typename std::enable_if<std::is_convertible<typename std::add_pointer<U>::type, typename std::add_pointer<T>::type>::value, safe_ptr<T>&>::type
+	operator=(U&& impl)
 	{
 		safe_ptr<T> temp(std::forward<T>(impl));
 		temp.swap(*this);
@@ -75,66 +94,129 @@ public:
 				
 	void swap(safe_ptr& other) { impl_.swap(other.impl_); }	
 	
-	std::shared_ptr<T> get_shared() const { return impl_; }
+	operator std::shared_ptr<T>() const { return impl_;}
+
+	template<class U>
+	bool owner_before(const safe_ptr<T>& ptr){ return impl_.owner_before(ptr.impl_); }
+
+	template<class U>
+	bool owner_before(const std::shared_ptr<U>& ptr){ return impl_.owner_before(ptr); }
+	
+	template<class D, class U> 
+	D* get_deleter(safe_ptr<U> const& ptr) { return impl_.get_deleter(); }
 	
 private:	
 	std::shared_ptr<T> impl_;
 };
 
 template<class T, class U>
-bool operator==(safe_ptr<T> const & a, safe_ptr<U> const & b)
+bool operator==(const safe_ptr<T>& a, const safe_ptr<U>& b)
 {
 	return a.get() == b.get();
 }
 
 template<class T, class U>
-bool operator!=(safe_ptr<T> const & a, safe_ptr<U> const & b)
+bool operator!=(const safe_ptr<T>& a, const safe_ptr<U>& b)
 {
 	return a.get() != b.get();
 }
 
 template<class T, class U>
-bool operator<(safe_ptr<T> const & a, safe_ptr<U> const & b)
+bool operator<(const safe_ptr<T>& a, const safe_ptr<U>& b)
 {
 	return a.get() < b.get();
 }
 
-template<class T> void swap(safe_ptr<T> & a, safe_ptr<T> & b)
+template<class T, class U>
+bool operator>(const safe_ptr<T>& a, const safe_ptr<U>& b)
+{
+	return a.get() > b.get();
+}
+
+template<class T, class U>
+bool operator>=(const safe_ptr<T>& a, const safe_ptr<U>& b)
+{
+	return a.get() >= b.get();
+}
+
+template<class T, class U>
+bool operator<=(const safe_ptr<T>& a, const safe_ptr<U>& b)
+{
+	return a.get() <= b.get();
+}
+
+template<class E, class T, class U>
+std::basic_ostream<E, T>& operator<<(std::basic_ostream<E, T>& out,	const safe_ptr<U>& p)
+{
+	return out << p.get();
+}
+
+template<class T> 
+void swap(safe_ptr<T>& a, safe_ptr<T>& b)
 {
 	a.swap(b);
 }
 
-template<class T> T* get_pointer(safe_ptr<T> const & p)
+template<class T> 
+T* get_pointer(safe_ptr<T> const& p)
 {
 	return p.get();
 }
 
+template <class T, class U>
+safe_ptr<T> static_pointer_cast(const safe_ptr<U>& p)
+{
+	return safe_ptr<T>(std::static_pointer_cast<T>(std::shared_ptr<U>(p)));
+}
+
+template <class T, class U>
+safe_ptr<T> const_pointer_cast(const safe_ptr<U>& p)
+{
+	return safe_ptr<T>(std::const_pointer_cast<T>(std::shared_ptr<U>(p)));
+}
+
+template <class T, class U>
+safe_ptr<T> dynamic_pointer_cast(const safe_ptr<U>& p)
+{
+	auto temp = std::dynamic_pointer_cast<T>(std::shared_ptr<U>(p));
+	if(!temp)
+		throw std::bad_cast();
+	return safe_ptr<T>(temp);
+}
+
 template<typename T>
 safe_ptr<T> make_safe()
 {
-	static_assert(!std::is_abstract<T>::value, "Cannot construct abstract class.");
 	return safe_ptr<T>();
 }
 
 template<typename T, typename P0>
 safe_ptr<T> make_safe(P0&& p0)
 {
-	static_assert(!std::is_abstract<T>::value, "Cannot construct abstract class.");
 	return safe_ptr<T>(std::make_shared<T>(std::forward<P0>(p0)));
 }
 
 template<typename T, typename P0, typename P1>
 safe_ptr<T> make_safe(P0&& p0, P1&& p1)
 {
-	static_assert(!std::is_abstract<T>::value, "Cannot construct abstract class.");
 	return safe_ptr<T>(std::make_shared<T>(std::forward<P0>(p0), std::forward<P1>(p1)));
 }
 
 template<typename T, typename P0, typename P1, typename P2>
 safe_ptr<T> make_safe(P0&& p0, P1&& p1, P2&& p2)
 {
-	static_assert(!std::is_abstract<T>::value, "Cannot construct abstract class.");
 	return safe_ptr<T>(std::make_shared<T>(std::forward<P0>(p0), std::forward<P1>(p1), std::forward<P2>(p2)));
 }
 
+template<typename T, typename P0, typename P1, typename P2, typename P3>
+safe_ptr<T> make_safe(P0&& p0, P1&& p1, P2&& p2, P3&& p3)
+{
+	return safe_ptr<T>(std::make_shared<T>(std::forward<P0>(p0), std::forward<P1>(p1), std::forward<P2>(p2), std::forward<P3>(p3)));
+}
+
+template<typename T, typename P0, typename P1, typename P2, typename P3, typename P4>
+safe_ptr<T> make_safe(P0&& p0, P1&& p1, P2&& p2, P3&& p3, P4&&)
+{
+	return safe_ptr<T>(std::make_shared<T>(std::forward<P0>(p0), std::forward<P1>(p1), std::forward<P2>(p2), std::forward<P3>(p3), std::forward<P3>(p4)));
+}
 }
\ No newline at end of file