将宏定义集中存放，以便于将来更好的支持module

librf/librf_macro.h

+#include "src/macro_def.inl"

librf/src/asio_task_1.10.0.inl

 	private:
 		Allocator allocator_;
 	};
-
-	//constexpr rf_task_t<> rf_task;
-#pragma warning(push)
-#pragma warning(disable : 4592)
-	__declspec(selectany) rf_task_t<> rf_task;
-#pragma warning(pop)
+	constexpr rf_task_t<> rf_task;
 
 	namespace detail {
 

librf/src/asio_task_1.12.0.inl

 	{
 		ASIO_CONSTEXPR rf_task_t() {}
 	};
-
-#if defined(ASIO_HAS_CONSTEXPR) || defined(GENERATING_DOCUMENTATION)
 	constexpr rf_task_t<> rf_task;
-#elif defined(ASIO_MSVC)
-	__declspec(selectany) rf_task_t<> rf_task;
-#endif
 
 	namespace librf {
 

librf/src/def.h

 #pragma once
 
-#define RESUMEF_LIB_INCLUDE	1
-
-//#include <yvals.h>
 #include <atomic>
 #include <chrono>
 #include <vector>
 #include <functional>
 #include <optional>
 #include <thread>
-
 #include <assert.h>
-
 #include <experimental/coroutine>
-//#include <experimental/generator>
 
-#define LIB_RESUMEF_VERSION 200101 // 2.1.1
+#define LIB_RESUMEF_VERSION 200102 // 2.1.2
 
 namespace resumef
 {
 
 	template<class... _Mutexes>
 	using scoped_lock = std::scoped_lock<_Mutexes...>;
+
+	constexpr size_t _Version = LIB_RESUMEF_VERSION;
 }
 
 #if RESUMEF_DEBUG_COUNTER
 	}
 }
 
-#if defined(RESUMEF_DLL_EXPORT)
-#	define RF_API __declspec(dllexport)
-#elif defined(RESUMEF_DLL_IMPORT)
-#	define RF_API __declspec(dllimport)
-#else
-#	define RF_API
-#endif
-
 #include "exception.inl"
 #include "type_traits.inl"
-
-#define co_yield_void co_yield nullptr
-#define co_return_void co_return nullptr
+#include "macro_def.inl"

librf/src/event.h

 			intptr_t _counter;
 			lock_type _lock;
 		public:
-			RF_API event_impl(intptr_t initial_counter_);
+			event_impl(intptr_t initial_counter_);
 
-			RF_API void signal();
-			RF_API void reset();
+			void signal();
+			void reset();
 
 			//如果已经触发了awaker,则返回true
-			RF_API bool wait_(const event_awaker_ptr& awaker);
+			bool wait_(const event_awaker_ptr& awaker);
 
 			template<class callee_t, class dummy_t = std::enable_if<!std::is_same<std::remove_cv_t<callee_t>, event_awaker_ptr>::value>>
 			decltype(auto) wait(callee_t&& awaker, dummy_t* dummy_ = nullptr)
 		event_impl_ptr _event;
 		struct wait_all_ctx;
 	public:
-		RF_API event_t(intptr_t initial_counter_ = 0);
+		event_t(intptr_t initial_counter_ = 0);
 
 		void signal() const
 		{
 
 
 
-		RF_API future_t<bool>
+		future_t<bool>
 			wait() const;
 		template<class _Rep, class _Period>
 		future_t<bool>
 
 
 
-		RF_API event_t(const event_t&) = default;
-		RF_API event_t(event_t&&) = default;
-		RF_API event_t& operator = (const event_t&) = default;
-		RF_API event_t& operator = (event_t&&) = default;
+		event_t(const event_t&) = default;
+		event_t(event_t&&) = default;
+		event_t& operator = (const event_t&) = default;
+		event_t& operator = (event_t&&) = default;
 
 	private:
 		template<class _Iter>
 		{
 			return wait_until_(clock_type::now() + dt);
 		}
-		RF_API future_t<bool> wait_until_(const clock_type::time_point& tp) const;
+		future_t<bool> wait_until_(const clock_type::time_point& tp) const;
 
 
-		RF_API static future_t<intptr_t> wait_any_(std::vector<event_impl_ptr>&& evts);
+		static future_t<intptr_t> wait_any_(std::vector<event_impl_ptr>&& evts);
 		inline static future_t<intptr_t> wait_any_for_(const clock_type::duration& dt, std::vector<event_impl_ptr>&& evts)
 		{
 			return wait_any_until_(clock_type::now() + dt, std::forward<std::vector<event_impl_ptr>>(evts));
 		}
-		RF_API static future_t<intptr_t> wait_any_until_(const clock_type::time_point& tp, std::vector<event_impl_ptr>&& evts);
+		static future_t<intptr_t> wait_any_until_(const clock_type::time_point& tp, std::vector<event_impl_ptr>&& evts);
 
 
-		RF_API static future_t<bool> wait_all_(std::vector<event_impl_ptr>&& evts);
+		static future_t<bool> wait_all_(std::vector<event_impl_ptr>&& evts);
 		inline static future_t<bool> wait_all_for_(const clock_type::duration& dt, std::vector<event_impl_ptr>&& evts)
 		{
 			return wait_all_until_(clock_type::now() + dt, std::forward<std::vector<event_impl_ptr>>(evts));
 		}
-		RF_API static future_t<bool> wait_all_until_(const clock_type::time_point& tp, std::vector<event_impl_ptr>&& evts);
+		static future_t<bool> wait_all_until_(const clock_type::time_point& tp, std::vector<event_impl_ptr>&& evts);
 	};
 
 }

librf/src/macro_def.inl

+#pragma once
+
+#define co_yield_void co_yield nullptr
+#define co_return_void co_return nullptr
+#define resumf_guard_lock(lker) (lker).lock(); resumef::scoped_lock<resumef::mutex_t> __resumf_guard##lker##__(std::adopt_lock, (lker))
+
+#if !defined(_DISABLE_RESUMEF_GO_MACRO)
+#define go (*::resumef::this_scheduler()) + 
+#define GO (*::resumef::this_scheduler()) + [=]()mutable->resumef::future_t<>
+#endif

librf/src/mutex.h

 			mutex_awaker_ptr _owner;
 			lock_type _lock;
 		public:
-			RF_API mutex_impl();
+			mutex_impl();
 
 			//如果已经触发了awaker,则返回true
-			RF_API bool lock_(const mutex_awaker_ptr& awaker);
-			RF_API bool try_lock_(const mutex_awaker_ptr& awaker);
-			RF_API void unlock();
+			bool lock_(const mutex_awaker_ptr& awaker);
+			bool try_lock_(const mutex_awaker_ptr& awaker);
+			void unlock();
 
 			template<class callee_t, class dummy_t = std::enable_if<!std::is_same<std::remove_cv_t<callee_t>, mutex_awaker_ptr>::value>>
 			decltype(auto) lock(callee_t&& awaker, dummy_t* dummy_ = nullptr)
 	private:
 		lock_impl_ptr _locker;
 	public:
-		RF_API mutex_t();
+		mutex_t();
 
 		void unlock() const
 		{
 		}
 
 
-		RF_API future_t<bool>
-			lock() const;
-		RF_API bool
-			try_lock() const;
+		future_t<bool> lock() const;
+		bool try_lock() const;
 
 		/*
 		template<class _Rep, class _Period>
 		*/
 
 
-		RF_API mutex_t(const mutex_t&) = default;
-		RF_API mutex_t(mutex_t&&) = default;
-		RF_API mutex_t& operator = (const mutex_t&) = default;
-		RF_API mutex_t& operator = (mutex_t&&) = default;
+		mutex_t(const mutex_t&) = default;
+		mutex_t(mutex_t&&) = default;
+		mutex_t& operator = (const mutex_t&) = default;
+		mutex_t& operator = (mutex_t&&) = default;
 	private:
 		inline future_t<bool> try_lock_for_(const clock_type::duration& dt) const
 		{
 			return try_lock_until_(clock_type::now() + dt);
 		}
-		RF_API future_t<bool> try_lock_until_(const clock_type::time_point& tp) const;
+		future_t<bool> try_lock_until_(const clock_type::time_point& tp) const;
 	};
-
-#if _HAS_CXX17
-#define resumf_guard_lock(lker) (lker).lock(); resumef::scoped_lock<resumef::mutex_t> __resumf_guard##lker##__(std::adopt_lock, (lker))
-#else
-#define resumf_guard_lock(lker) (lker).lock(); resumef::scoped_lock<resumef::mutex_t> __resumf_guard##lker##__((lker), std::adopt_lock)
-#endif
-
 }

librf/src/promise.h

 #pragma once
 #include "state.h"
 
+#pragma push_macro("new")
+#undef new
+
 namespace resumef
 {
 	struct suspend_on_initial;
 
 }
 
+#pragma pop_macro("new")

librf/src/promise.inl

-
-#pragma once
-
-#pragma once
+#pragma once
 
 namespace resumef
 {

librf/src/rf_task.h

 	struct task_base_t
 	{
 		task_base_t() = default;
-		RF_API virtual ~task_base_t();
+		virtual ~task_base_t();
 
 		state_base_t* get_state() const
 		{

librf/src/scheduler.h

 
 		timer_mgr_ptr _timer;
 
-		RF_API void new_task(task_base_t* task);
+		void new_task(task_base_t* task);
 		//void cancel_all_task_();
 
 	public:
-		RF_API void run_one_batch();
-		RF_API void run_until_notask();
-		RF_API void run();
-		//RF_API void break_all();
+		void run_one_batch();
+		void run_until_notask();
+		void run();
+		//void break_all();
 
-		template<class _Ty, typename = std::enable_if_t<std::is_callable<_Ty>::value || is_future_v<_Ty> || is_generator_v<_Ty> >>
+		template<class _Ty, typename = std::enable_if_t<std::is_callable_v<_Ty> || is_future_v<_Ty> || is_generator_v<_Ty> >>
 		inline void operator + (_Ty&& t_)
 		{
 			if constexpr (std::is_callable<_Ty>::value)
 		friend struct task_base;
 		friend struct local_scheduler;
 	protected:
-		RF_API scheduler_t();
+		scheduler_t();
 	public:
-		RF_API ~scheduler_t();
+		~scheduler_t();
 
 		scheduler_t(scheduler_t&& right_) = delete;
 		scheduler_t& operator = (scheduler_t&& right_) = delete;
 
 	struct local_scheduler
 	{
-		RF_API local_scheduler();
-		RF_API ~local_scheduler();
+		local_scheduler();
+		~local_scheduler();
 
 		local_scheduler(local_scheduler&& right_) = delete;
 		local_scheduler& operator = (local_scheduler&& right_) = delete;
 	}
 #endif
 
-#if !defined(_DISABLE_RESUMEF_GO_MACRO)
-#define go (*::resumef::this_scheduler()) + 
-#define GO (*::resumef::this_scheduler()) + [=]()mutable->resumef::future_t<>
-#endif
-
 	//--------------------------------------------------------------------------------------------------
 }

librf/src/sleep.h

 {
 	struct scheduler_t;
 
-	RF_API future_t<> sleep_until_(const std::chrono::system_clock::time_point& tp_, scheduler_t& scheduler_);
+	future_t<> sleep_until_(const std::chrono::system_clock::time_point& tp_, scheduler_t& scheduler_);
 
 	inline future_t<> sleep_for_(const std::chrono::system_clock::duration& dt_, scheduler_t& scheduler_)
 	{

librf/src/timer.h

 	public:
 		timer_map_type		_runing_timers;
 
-		RF_API timer_manager();
-		RF_API ~timer_manager();
+		timer_manager();
+		~timer_manager();
 
 		template<class _Rep, class _Period, class _Cb>
 		timer_target_ptr add(const std::chrono::duration<_Rep, _Period> & dt_, _Cb && cb_)
 			return{ this, add(tp_, std::forward<_Cb>(cb_)) };
 		}
 
-		RF_API bool stop(const timer_target_ptr & sptr);
+		bool stop(const timer_target_ptr & sptr);
 
 		inline bool empty() const
 		{
 			return _added_timers.empty() && _runing_timers.empty();
 		}
-		RF_API void clear();
-		RF_API void update();
+		void clear();
+		void update();
 
 		template<class _Cb>
 		timer_target_ptr add_(const duration_type & dt_, _Cb && cb_)
 			return add_(std::make_shared<timer_target>(tp_, std::forward<_Cb>(cb_)));
 		}
 	private:
-		RF_API timer_target_ptr add_(const timer_target_ptr & sptr);
+		timer_target_ptr add_(const timer_target_ptr & sptr);
 		static void call_target_(const timer_target_ptr & sptr, bool canceld);
 	};
 

librf/src/utils.h

 	template<typename _Function>
 	using is_callable = decltype(_IsCallable(std::declval<_Function>(), 0));
 
-#if _HAS_CXX17
 	template<typename _Function>
-	_INLINE_VAR constexpr bool is_callable_v = is_callable<_Function>::value;
-#endif
+	constexpr bool is_callable_v = is_callable<_Function>::value;
 }

librf/src/when.h

 #pragma once
-#if RESUMEF_USE_BOOST_ANY
-#include <boost/any.hpp>
-namespace resumef
-{
-	using any_t = boost::any;
-	using boost::any_cast;
-}
-#else
+
 #include <any>
 namespace resumef
 {
 	using any_t = std::any;
 	using std::any_cast;
 }
-#endif
 
 #include "_awaker.h"
 #include "promise.h"
 			intptr_t _counter;
 			lock_type _lock;
 		public:
-			RF_API when_impl(intptr_t initial_counter_);
+			when_impl(intptr_t initial_counter_);
 
-			RF_API void signal();
+			void signal();
 
 			//如果已经触发了awaker,则返回true
-			RF_API bool wait_(const when_awaker_ptr & awaker);
+			bool wait_(const when_awaker_ptr & awaker);
 
             template<class callee_t, class dummy_t = std::enable_if<!std::is_same<std::remove_cv_t<callee_t>, when_awaker_ptr>::value>>
 			auto wait(callee_t && awaker, dummy_t * dummy_ = nullptr)

vs_proj/librf.vcxproj

   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\librf\librf.h" />
+    <ClInclude Include="..\librf\librf_macro.h" />
     <ClInclude Include="..\librf\src\asio_task.h" />
     <ClInclude Include="..\librf\src\awaitable.h" />
     <ClInclude Include="..\librf\src\channel.h" />
     <None Include="..\librf\src\asio_task_1.10.0.inl" />
     <None Include="..\librf\src\asio_task_1.12.0.inl" />
     <None Include="..\librf\src\exception.inl" />
+    <None Include="..\librf\src\macro_def.inl" />
     <None Include="..\librf\src\promise.inl" />
     <None Include="..\librf\src\state.inl" />
     <None Include="..\librf\src\type_traits.inl" />

vs_proj/librf.vcxproj.filters

     <ClInclude Include="..\librf\src\generator.h">
       <Filter>librf\src</Filter>
     </ClInclude>
+    <ClInclude Include="..\librf\librf_macro.h">
+      <Filter>librf</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="..\librf\src\asio_task_1.12.0.inl">
       <Filter>librf\src</Filter>
     </None>
     <None Include="..\README.md" />
+    <None Include="..\librf\src\macro_def.inl">
+      <Filter>librf\src</Filter>
+    </None>
   </ItemGroup>
 </Project>