View difference between Paste ID: zpYiY1Qe and VjVTfsJE

 #include <functional>
 #include <cassert>
 #include <iterator>
 #include <iostream>
 #ifdef _WIN32
-#   define WIN32_LEAD_AND_MEAN
+#   ifdef WIN32_LEAD_AND_MEAN
-#   include <Windows.h>
+#       include <Windows.h>
-#   undef WIN32_LEAD_AND_MEAN
+
 #       define WIN32_LEAD_AND_MEAN 1
 #       include <Windows.h>
 #       undef WIN32_LEAD_AND_MEAN
 #   endif
-namespace Fiber {
+
-    /** \brief 辅助类
+
 #   include <memory>
-     * 存放各种静态变量
+
-     * 放于Fiber<...>外，确保类型无关
+
 namespace FiberSpace {
     class FiberHelper {
         template <typename YieldValueType>
         friend class Fiber;
 
-        /// \brief 主纤程信息
+#if defined(_WIN32) && (!defined(_WIN32_WINNT) || (_WIN32_WINNT) < 0x600)
-        static void* pMainFiber;
+        // Vista之前不支持IsThreadAFiber
         /// \brief 表示是否需要线纤互转
-        /// \brief 主纤程信息
+        static bool bNeedConvert;
-        static ucontext_t ctx_main;
+
-        /// \brief 子纤程信息
+        /// \brief 存放当前纤程的param指针
-        static ucontext_t ctx_fnew;
+        static void* paraThis;
-        static uint8_t fnew_stack[SIGSTKSZ];
+
 #if defined(_WIN32) && (!defined(_WIN32_WINNT) || (_WIN32_WINNT) < 0x600)
-        /// \brief 子纤程是否结束
+    bool FiberHelper::bNeedConvert = true;
-        static bool flagFinish;
+
-        static std::exception_ptr eptr;
+    void* FiberHelper::paraThis = nullptr;
 
     /** \brief 主纤程类
-    void* FiberHelper::pMainFiber = nullptr;
+
      * 目前可以嵌套开纤程，但最好只在每个纤程中新开一个纤程
-    ucontext_t FiberHelper::ctx_main, FiberHelper::ctx_fnew;
+
-    uint8_t FiberHelper::fnew_stack[SIGSTKSZ];
+     * \warning 无线程安全
      * \param 子纤程返回类型
-    bool FiberHelper::flagFinish = false;
+
-    std::exception_ptr FiberHelper::eptr;
+
     class Fiber {
         static_assert(!std::is_same<YieldValueType, void>::value, "A fiber which return void is unsupported");
         typedef std::function<YieldValueType ()> FuncType;
-     * 只支持创建一个实例
+
-     * 各种不安全&不支持，玩玩足矣
+        /** \brief 纤程参数结构体
          *
-     * \todo 改用单例模式？
+         * 通过子纤程入口函数参数传入子纤程
          */
         struct Param {
             template <typename Fn>
             Param(Fn&& f)
-        static YieldValueType yieldedValue;
+                : func(std::forward<Fn>(f))
 #ifndef _WIN32
                 // 只能放在堆里，否则SIGSRV，原因不知
                 , fnew_stack(new uint8_t[SIGSTKSZ])
 #endif
                 {};
             /// \brief 子纤程返回值
-         * \warning 只支持创建一个Fiber实例
+            YieldValueType yieldedValue;
             /// \brief 存储子纤程抛出的异常
             std::exception_ptr eptr;
             /// \brief 子纤程是否结束
-        Fiber(Fn&& f): func(std::forward<Fn>(f)) {
+            bool flagFinish;
             /// \brief 真子纤程入口
-            assert(FiberHelper::pMainFiber == nullptr && "Only one fiber is supported");
+            FuncType func;
-#   if _WIN32_WINNT >= 0x0400
+            /// \brief 纤程信息
-            FiberHelper::pMainFiber = ::ConvertThreadToFiberEx(nullptr, FIBER_FLAG_FLOAT_SWITCH);
+
             PVOID pMainFiber, pNewFiber;
-            pNewFiber = ::CreateFiberEx(0, 0, FIBER_FLAG_FLOAT_SWITCH, &fEntry, &func);
+            bool isFormerAThread;
 #else
-#       warning See: msdn.microsoft.com/en-us/library/ms682117.aspx
+            ucontext_t ctx_main, ctx_fnew;
-            FiberHelper::pMainFiber = ::ConvertThreadToFiber(nullptr);
+            const std::unique_ptr<uint8_t[]> fnew_stack;
-            pNewFiber = ::CreateFiber(0, &fEntry, &func);
+
         } param;
 
-            ucontext_t* const uctx = &FiberHelper::ctx_fnew;
+
-            ::getcontext(&FiberHelper::ctx_fnew);
+
-            uctx->uc_stack.ss_sp = FiberHelper::fnew_stack;
+
-            uctx->uc_stack.ss_size = sizeof(FiberHelper::fnew_stack);
+
-            uctx->uc_link = &FiberHelper::ctx_main;
+
-            ::makecontext(uctx, reinterpret_cast<void (*)()>(&fEntry), 1, &func);
+
          */
-            FiberHelper::flagFinish = false;
+
         Fiber(Fn&& f): param(std::forward<Fn>(f)) {
 #ifdef _WIN32
 #   if defined(_WIN32_WINNT) && (_WIN32_WINNT) > 0x600
             // 貌似MinGW杯具？
             param.isFormerAThread = IsThreadAFiber() == FALSE;
-         * \warning 主类析构时子纤程必须已经结束
+
             param.isFormerAThread = FiberHelper::bNeedConvert;
 #   endif
-            assert(FiberHelper::flagFinish == true);
+            if (param.isFormerAThread) {
 #   if defined(_WIN32_WINNT) && (_WIN32_WINNT) > 0x502
-            ::DeleteFiber(pNewFiber);
+                param.pMainFiber = ::ConvertThreadToFiberEx(nullptr, FIBER_FLAG_FLOAT_SWITCH);
-            ::ConvertFiberToThread();
+
-            FiberHelper::pMainFiber = nullptr;
+#       warning See: msdn.microsoft.com/en-us/library/ms682117
                 param.pMainFiber = ::ConvertThreadToFiber(nullptr);
 #   endif
 #   if !(defined(_WIN32_WINNT) && (_WIN32_WINNT) > 0x600)
                 FiberHelper::bNeedConvert = false;
 #   endif
             } else {
                 param.pMainFiber = ::GetCurrentFiber();
             }
             // default stack size
 #   if defined(_WIN32_WINNT) && (_WIN32_WINNT) > 0x502
             param.pNewFiber = ::CreateFiberEx(0, 0, FIBER_FLAG_FLOAT_SWITCH, &fEntry, &param);
-            assert(FiberHelper::flagFinish == false);
+
 #       warning See: msdn.microsoft.com/en-us/library/ms682406
-            assert(pNewFiber != nullptr);
+            param.pNewFiber = ::CreateFiber(0, &fEntry, nullptr);
-            ::SwitchToFiber(pNewFiber);
+
 #else
-            ::swapcontext(&FiberHelper::ctx_main, &FiberHelper::ctx_fnew);
+            ::getcontext(&param.ctx_fnew);
             param.ctx_fnew.uc_stack.ss_sp = param.fnew_stack.get();
-            if (!(FiberHelper::eptr == std::exception_ptr()))
+            param.ctx_fnew.uc_stack.ss_size = SIGSTKSZ;
-                std::rethrow_exception(FiberHelper::eptr);
+            param.ctx_fnew.uc_link = &param.ctx_main;
-            return std::move(yieldedValue);
+            ::makecontext(&param.ctx_fnew, &fEntry, 0);
 #endif
             param.flagFinish = false;
         }
         /** \brief 析构函数
          *
          * 删除子纤程，并将主纤程转回线程
-        bool isFinished() { return FiberHelper::flagFinish; }
+
          * \warning 主类析构时子纤程必须已经结束(return)
          */
         ~Fiber() {
             if (!isFinished())
                 std::terminate();
 #ifdef _WIN32
             ::DeleteFiber(param.pNewFiber);
             if (param.isFormerAThread) {
-            yieldedValue = std::move(value);
+                ::ConvertFiberToThread();
 #   if !(defined(_WIN32_WINNT) && (_WIN32_WINNT) > 0x600)
-            assert(FiberHelper::pMainFiber != nullptr);
+                FiberHelper::bNeedConvert = true;
-            assert(GetCurrentFiber() != FiberHelper::pMainFiber);
+
-            ::SwitchToFiber(FiberHelper::pMainFiber);
+
 #endif
-            ::swapcontext(&FiberHelper::ctx_fnew, &FiberHelper::ctx_main);
+
 
         /** \brief 调用子纤程
          *
          * 程序流程转入子线程
-        /** \brief 子纤程入口的warpper
+
          * \warning 子纤程必须尚未结束
-         * 不足为外人道也
+
          */
-        static void
+
             assert(isFinished() == false);
-        WINAPI
+            void* oldPara = FiberHelper::paraThis;
             FiberHelper::paraThis = &param;
-        fEntry(void* param) {
+
-            assert(FiberHelper::flagFinish == false);
+            ::SwitchToFiber(param.pNewFiber);
-            assert(param != nullptr);
+
-            FiberHelper::flagFinish = false;
+            ::swapcontext(&param.ctx_main, &param.ctx_fnew);
-            FuncType& f = *reinterpret_cast<FuncType *>(param);
+
             FiberHelper::paraThis = oldPara;
-                yieldedValue = f();
+            if (!(param.eptr == std::exception_ptr()))
-            } catch (...) { // 没finally淡腾
+                std::rethrow_exception(param.eptr);
-                FiberHelper::eptr = std::current_exception();
+            return std::move(param.yieldedValue);
-                FiberHelper::flagFinish = true;
+
 
-                ::SwitchToFiber(FiberHelper::pMainFiber);
+
          * \return 子纤程已经结束(return)返回true，否则false
-                return;
+
         bool isFinished() { return param.flagFinish; }
 
-            FiberHelper::flagFinish = true;
+
          *
-            ::SwitchToFiber(FiberHelper::pMainFiber);
+
          *          参数类型必须与子纤程返回值相同，无类型安全
          * \param 输出到主纤程的值
          */
         static void yield(YieldValueType value) {
-        /// \brief 子纤程信息
+            assert(FiberHelper::paraThis != nullptr && "Fiber::yield() called with no active fiber");
-        void* pNewFiber;
+            Param& param = *reinterpret_cast<Param *>(FiberHelper::paraThis);
             param.yieldedValue = std::move(value);
-        /// \brief 真子纤程入口
+
-        FuncType func;
+            ::SwitchToFiber(param.pMainFiber);
 #else
             ::swapcontext(&param.ctx_fnew, &param.ctx_main);
-    YieldValueType Fiber<YieldValueType>::yieldedValue;
+
         }
 
     private:
         /// \brief 子纤程入口的warpper
 
 #ifdef _WIN32
-     * \bug C++中，iterator的有效范围为[&front, &back+1)
+        static void WINAPI fEntry(void *) {
-     *      而纤程需要java/.NET的(&front-1, back]
+
-     *      暂时无解，保留待改
+        static void fEntry() {
 #endif
             assert(FiberHelper::paraThis != nullptr);
             Param& param = *reinterpret_cast<Param *>(FiberHelper::paraThis);
             param.flagFinish = false;
             try {
                 param.yieldedValue = param.func();
             } catch (...) {
                 param.eptr = std::current_exception();
             }
             param.flagFinish = true;
 #ifdef _WIN32
             ::SwitchToFiber(param.pMainFiber);
 #endif
         }
     };
 
     /** \brief 纤程迭代器类
      *
      * 它通过使用 yield 函数对数组或集合类执行自定义迭代。
      * 用于 C++11 for (...:...)
      */
     template <typename YieldValueType>
     struct FiberIterator: std::iterator<std::input_iterator_tag, YieldValueType> {
         /// \brief 迭代器尾
         FiberIterator(): fiber(nullptr), value() {}
         /** \brief 迭代器首
          * \param 主线程类的引用
          */
         FiberIterator(Fiber<YieldValueType>& _f): fiber(&_f), value(_f.call()) {}
 
         /// \brief 转入子纤程
         FiberIterator& operator ++() {
             assert(fiber != nullptr);
             if (!fiber->isFinished())
                 value = fiber->call();
             else
-         * \warning 最好别干别的 ;P
+
             return *this;
         }
         // 返回临时对象没问题吧-_-!!
         FiberIterator operator ++(int) {
             FiberIterator tmp(*this);
             ++*this;
             return tmp;
         }
 
         /// \brief 取得返回值
         YieldValueType& operator *() {
             assert(fiber != nullptr);
             return value;
         }
-    /// 用于 C++11 for (...:...)
+
         /** \brief 比较迭代器相等
          *
          * 通常用于判断迭代是否结束
          * 最好别干别的 ;P
          */
         bool operator ==(const FiberIterator& rhs) {
-    /// 用于 C++11 for (...:...)
+
         }
         bool operator !=(const FiberIterator& rhs) {
             return !(*this == rhs);
         }
 
     private:
         Fiber<YieldValueType>* fiber;
         YieldValueType value;
     };
 
-    Fiber::Fiber<int>::yield(++i);
+
     template <typename YieldValueType>
     FiberIterator<YieldValueType> begin(Fiber<YieldValueType>& fiber) {
         return FiberIterator<YieldValueType>(fiber);
     }
 
     /// \brief 返回迭代器尾
     template <typename YieldValueType>
-        Fiber::Fiber<int>::yield(beg++);
+
         return FiberIterator<YieldValueType>();
     }
 }
-int TestException() {
+
-    throw exception();
+
 using FiberSpace::Fiber;
 
 int Test(int& i) {
     cout << "func, i = " << i << endl;
-        int i = 0, t;
+
-        cout << "main, i = " << i << endl;
+    Fiber<int>::yield(++i);
-        // 把主线程转化为纤程，并创建一个子纤程。参数为子纤程入口
+
-        Fiber::Fiber<int> fiber(std::bind(Test, std::ref(i)));
+
-        // 流程转入子线程
+
-        t = fiber.call();
+
-        cout << "main, Test yield: " << t << endl;
+
-        t = fiber.call();
+
-        cout << "main, Test return: " << t << endl;
+
-        cout << "main, i = " << i << endl;
+        Fiber<int>::yield(beg++);
-        // 确保fiber正常析构
+
 }
 
-        // VC10: ╮(╯▽╰)╭
+long Test3() {
-        for (int i : Fiber::Fiber<int>(std::bind(Test2, 1, 10)))
+    auto testF = [] () -> int {
-            cout << i << '\t';
+        Fiber<int>::yield(1);
-        cout << endl;
+        Fiber<int>::yield(2);
         return 3;
     };
-        try {
+    for (auto i : Fiber<int>(testF))
-            Fiber::Fiber<int> fiber(TestException);
+        Fiber<long>::yield(i);
-            fiber.call();
+    return 4;
-        } catch (exception&) {
+
-            cout << "Exception catched!" << endl;
+
 long TestException() {
     auto testF = [] () -> int {
         Fiber<int> fiber([] () -> int { throw exception(); return 0; });
-/* Expected Output:
+        return fiber.call();
     };
     try {
         return Fiber<int>(testF).call();
     } catch (...) {
         cout << "Exception catched in TestException()" << endl;
         throw;
-0       1       2       3       4       5       6       7       8       9
+
 }
 
 class DerivedFiber: public Fiber<char> {
 public:
     DerivedFiber(): Fiber(std::bind(&DerivedFiber::run, this)) {}
 
 private:
     char run() {
         puts("Derived fiber running.");
         return 0;
     }
 };
 
 char fiberFunc() {
     puts("Composed fiber running.");
     Fiber<char>::yield(0);
     puts("Composed fiber running.");
     return 0;
 }
 
 int main() {
     {
     // 测试基本流程转换
     int i = 0, t;
     cout << "main, i = " << i << endl;
     // 把主线程转化为纤程，并创建一个子纤程。参数为子纤程入口
     Fiber<int> fiber(std::bind(Test, std::ref(i)));
     // 流程转入子线程
     t = fiber.call();
     cout << "main, Test yield: " << t << endl;
     t = fiber.call();
     cout << "main, Test return: " << t << endl;
     cout << "main, i = " << i << endl;
     // 确保fiber正常析构
     }
     {
     // Test from dlang.org
     // create instances of each type
     unique_ptr<DerivedFiber> derived(new DerivedFiber);
     unique_ptr<Fiber<char>> composed(new Fiber<char>(&fiberFunc));
 
     // call both fibers once
     derived->call();
     composed->call();
     puts("Execution returned to calling context.");
     composed->call();
 
     // since each fiber has run to completion, each should have state TERM
     assert( derived->isFinished() );
     assert( composed->isFinished() );
     }
     // 测试循环yield
     for (Fiber<int> fiber(std::bind(Test2, 1, 10)); !fiber.isFinished();)
         cout << fiber.call() << ' ';
     cout << endl;
 
     // 测试返回非基本类型，foreach
     // VC10: ╮(╯▽╰)╭
     for (const string& s : Fiber<string>([] () -> std::string {
         Fiber<string>::yield("Hello");
         Fiber<string>::yield("World");
         return "!!!!!";
     })) {
         cout << s << endl;
     }
 
     // 测试深层调用、返回
     for (auto i : Fiber<long>(Test3))
         cout << i << ' ';
     cout << endl;
 
 #if !(defined(__GNUC__) && defined(_WIN32))
     // 测试深层调用及异常安全
     // Test fail with MinGW
     try {
         Fiber<long> fiber(TestException);
         fiber.call();
     } catch (exception&) {
         cout << "Exception catched in main()!" << endl;
     }
 #endif
 }
 /*
 Tested with VS2010(icl), MinGW-g++, VMware-archlinux-g++
 Expected Output:
 main, i = 0
 func, i = 0
 main, Test yield: 1
 func, i = 1
 main, Test return: 2
 main, i = 2
 Derived fiber running.
 Composed fiber running.
 Execution returned to calling context.
 Composed fiber running.
 1 2 3 4 5 6 7 8 9 10
 Hello
 World
 !!!!!
 1 2 3 4
 Exception catched in TestException()
 Exception catched in main()!
 */