From e59cf7b09e7388d369e8d2bf73501cde79c28708 Mon Sep 17 00:00:00 2001
From: Toni Uhlig <matzeton@googlemail.com>
Date: Thu, 8 Apr 2021 16:43:58 +0200
Subject: Squashed 'EASTL/' content from commit fad5471

git-subtree-dir: EASTL
git-subtree-split: fad54717f8e4ebb13b20095da7efd07a53af0f10
---
 include/EASTL/fixed_function.h | 218 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 218 insertions(+)
 create mode 100644 include/EASTL/fixed_function.h

(limited to 'include/EASTL/fixed_function.h')

diff --git a/include/EASTL/fixed_function.h b/include/EASTL/fixed_function.h
new file mode 100644
index 0000000..6aed768
--- /dev/null
+++ b/include/EASTL/fixed_function.h
@@ -0,0 +1,218 @@
+/////////////////////////////////////////////////////////////////////////////
+// Copyright (c) Electronic Arts Inc. All rights reserved.
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef EASTL_FIXED_FUNCTION_H
+#define EASTL_FIXED_FUNCTION_H
+
+#if defined(EA_PRAGMA_ONCE_SUPPORTED)
+	#pragma once
+#endif
+
+#include <EASTL/internal/function_detail.h>
+
+namespace eastl
+{
+	template <int, typename>
+	class fixed_function;
+
+	namespace internal
+	{
+		template <typename>
+		struct is_fixed_function
+			: public eastl::false_type {};
+
+		template <int SIZE_IN_BYTES, typename R, typename... Args>
+		struct is_fixed_function<eastl::fixed_function<SIZE_IN_BYTES, R(Args...)>>
+			: public eastl::true_type {};
+
+		template<typename T>
+		EA_CONSTEXPR bool is_fixed_function_v = is_fixed_function<T>::value;
+	}
+
+	#define EASTL_INTERNAL_FIXED_FUNCTION_STATIC_ASSERT(TYPE)                    \
+		static_assert(sizeof(TYPE) <= sizeof(typename Base::FunctorStorageType), \
+					  "fixed_function local buffer is not large enough to hold the callable object.")
+
+    #define EASTL_INTERNAL_FIXED_FUNCTION_NEW_SIZE_STATIC_ASSERT(NEW_SIZE_IN_BYTES) \
+		static_assert(SIZE_IN_BYTES >= NEW_SIZE_IN_BYTES,                           \
+					  "fixed_function local buffer is not large enough to hold the new fixed_function type.")
+
+	template <typename Functor>
+	using EASTL_DISABLE_OVERLOAD_IF_FIXED_FUNCTION =
+	    eastl::disable_if_t<internal::is_fixed_function_v<eastl::decay_t<Functor>>>;
+
+
+	// fixed_function
+	//
+	template <int SIZE_IN_BYTES, typename R, typename... Args>
+	class fixed_function<SIZE_IN_BYTES, R(Args...)> : public internal::function_detail<SIZE_IN_BYTES, R(Args...)>
+	{
+		using Base = internal::function_detail<SIZE_IN_BYTES, R(Args...)>;
+
+	public:
+		using typename Base::result_type;
+
+		fixed_function() EA_NOEXCEPT = default;
+		fixed_function(std::nullptr_t p) EA_NOEXCEPT
+			: Base(p)
+		{
+		}
+
+		fixed_function(const fixed_function& other)
+			: Base(other)
+		{
+		}
+
+		fixed_function(fixed_function&& other)
+			: Base(eastl::move(other))
+		{
+		}
+
+		template <typename Functor,
+		          typename = EASTL_INTERNAL_FUNCTION_VALID_FUNCTION_ARGS(Functor, R, Args..., Base, fixed_function),
+		          typename = EASTL_DISABLE_OVERLOAD_IF_FIXED_FUNCTION<Functor>>
+		fixed_function(Functor functor)
+		    : Base(eastl::move(functor))
+		{
+			EASTL_INTERNAL_FIXED_FUNCTION_STATIC_ASSERT(Functor);
+		}
+
+		template<int NEW_SIZE_IN_BYTES>
+		fixed_function(const fixed_function<NEW_SIZE_IN_BYTES, R(Args...)>& other)
+			: Base(other)
+		{
+			EASTL_INTERNAL_FIXED_FUNCTION_NEW_SIZE_STATIC_ASSERT(NEW_SIZE_IN_BYTES);
+		}
+
+		template<int NEW_SIZE_IN_BYTES>
+		fixed_function(fixed_function<NEW_SIZE_IN_BYTES, R(Args...)>&& other)
+			: Base(eastl::move(other))
+		{
+			EASTL_INTERNAL_FIXED_FUNCTION_NEW_SIZE_STATIC_ASSERT(NEW_SIZE_IN_BYTES);
+		}
+
+		~fixed_function() EA_NOEXCEPT = default;
+
+		fixed_function& operator=(const fixed_function& other)
+		{
+			Base::operator=(other);
+			return *this;
+		}
+
+		fixed_function& operator=(fixed_function&& other)
+		{
+			Base::operator=(eastl::move(other));
+			return *this;
+		}
+
+		fixed_function& operator=(std::nullptr_t p) EA_NOEXCEPT
+		{
+			Base::operator=(p);
+			return *this;
+		}
+
+		template<int NEW_SIZE_IN_BYTES>
+		fixed_function& operator=(const fixed_function<NEW_SIZE_IN_BYTES, R(Args...)>& other)
+		{
+			EASTL_INTERNAL_FIXED_FUNCTION_NEW_SIZE_STATIC_ASSERT(NEW_SIZE_IN_BYTES);
+
+			Base::operator=(other);
+			return *this;
+		}
+
+		template<int NEW_SIZE_IN_BYTES>
+		fixed_function& operator=(fixed_function<NEW_SIZE_IN_BYTES, R(Args...)>&& other)
+		{
+			EASTL_INTERNAL_FIXED_FUNCTION_NEW_SIZE_STATIC_ASSERT(NEW_SIZE_IN_BYTES);
+
+			Base::operator=(eastl::move(other));
+			return *this;
+		}
+
+		template <typename Functor,
+		          typename = EASTL_INTERNAL_FUNCTION_VALID_FUNCTION_ARGS(Functor, R, Args..., Base, fixed_function),
+		          typename = EASTL_DISABLE_OVERLOAD_IF_FIXED_FUNCTION<Functor>>
+		fixed_function& operator=(Functor&& functor)
+		{
+			EASTL_INTERNAL_FIXED_FUNCTION_STATIC_ASSERT(eastl::decay_t<Functor>);
+			Base::operator=(eastl::forward<Functor>(functor));
+			return *this;
+		}
+
+		template <typename Functor>
+		fixed_function& operator=(eastl::reference_wrapper<Functor> f) EA_NOEXCEPT
+		{
+			EASTL_INTERNAL_FIXED_FUNCTION_STATIC_ASSERT(eastl::reference_wrapper<Functor>);
+			Base::operator=(f);
+			return *this;
+		}
+
+		void swap(fixed_function& other) EA_NOEXCEPT
+		{
+			Base::swap(other);
+		}
+
+		explicit operator bool() const EA_NOEXCEPT
+		{
+			return Base::operator bool();
+		}
+
+		R operator ()(Args... args) const
+		{
+			return Base::operator ()(eastl::forward<Args>(args)...);
+		}
+
+	#if EASTL_RTTI_ENABLED
+		const std::type_info& target_type() const EA_NOEXCEPT
+		{
+			return Base::target_type();
+		}
+
+		template <typename Functor>
+		Functor* target() EA_NOEXCEPT
+		{
+			return Base::target();
+		}
+
+		template <typename Functor>
+		const Functor* target() const EA_NOEXCEPT
+		{
+			return Base::target();
+		}
+	#endif
+	};
+
+	template <int S, typename R, typename... Args>
+	bool operator==(const fixed_function<S, R(Args...)>& f, std::nullptr_t) EA_NOEXCEPT
+	{
+		return !f;
+	}
+
+	template <int S, typename R, typename... Args>
+	bool operator==(std::nullptr_t, const fixed_function<S, R(Args...)>& f) EA_NOEXCEPT
+	{
+		return !f;
+	}
+
+	template <int S, typename R, typename... Args>
+	bool operator!=(const fixed_function<S, R(Args...)>& f, std::nullptr_t) EA_NOEXCEPT
+	{
+		return !!f;
+	}
+
+	template <int S, typename R, typename... Args>
+	bool operator!=(std::nullptr_t, const fixed_function<S, R(Args...)>& f) EA_NOEXCEPT
+	{
+		return !!f;
+	}
+
+	template <int S, typename R, typename... Args>
+	void swap(fixed_function<S, R(Args...)>& lhs, fixed_function<S, R(Args...)>& rhs)
+	{
+		lhs.swap(rhs);
+	}
+
+} // namespace eastl
+
+#endif // EASTL_FIXED_FUNCTION_H
-- 
cgit v1.2.3