#include <stdio.h>
#include <libgo/coroutine.h>
int main(int argc, char **argv)
{
    go []{
        printf("1\n");
        co_yield;
        printf("2\n");
    };
    go []{
        printf("3\n");
        co_yield;
        printf("4\n");
    };
    return 0;
}

$vcpkg.exe install libgo

$ mkdir build
$ cd build
$ cmake ..

find_package(libgo CONFIG REQUIRED)
target_link_libraries(main PRIVATE libgo::libgo)

#include <libgo/coroutine.h>
#include <stdio.h>
#include <thread>
void foo()
{
    printf("function pointer\n");
}
struct A {
    void fA() { printf("std::bind\n"); }
    void fB() { printf("std::function\n"); }
};
int main()
{
    //----------------------------------
    // 使用关键字go创建协程, go后面可以使用:
    //     1.void(*)()函数指针, 比如:foo.
    //     2.也可以使用无参数的lambda, std::bind对象, function对象, 
    //     3.以及一切可以无参调用的仿函数对象
    //   注意不要忘记句尾的分号";".
    go foo;
    go []{
        printf("lambda\n");
    };
    go std::bind(&A::fA, A());
    std::function<void()> fn(std::bind(&A::fB, A()));
    go fn;
    // 也可以使用go_stack创建指定栈大小的协程
    //   创建拥有10MB大栈的协程
    go co_stack(10 * 1024 * 1024) []{
        printf("large stack\n");
    };
    // 协程创建以后不会立即执行，而是暂存至可执行列表中，等待调度器调度。
    // co_sched是默认的协程调度器，用户也可以使用自创建的协程调度器。 
    // 当仅使用一个线程进行协程调度时, 协程地执行会严格地遵循其创建顺序.
    // 仅使用主线程调度协程.
    // co_sched.Start();
    // 以下代码可以使用等同于cpu核心数的线程调度协程.(包括主线程)
    // co_sched.Start(0);
    // 以下代码允许调度器自由扩展线程数，上限为1024.
    // 当有线程被协程阻塞时, 调度器会启动一个新的线程, 以此保障
    // 可用线程数总是等于Start的第一个参数(0表示cpu核心数).
    // co_sched.Start(0, 1024);
    // 如果不想让调度器卡住主线程, 可以使用以下方式:
    std::thread t([]{ co_sched.Start(); });
    t.detach();
    co_sleep(100);
    //----------------------------------
    //----------------------------------
    // 除了上述的使用默认的调度器外, 还可以自行创建额外的调度器,
    // 协程只会在所属的调度器中被调度, 创建额外的调度器可以实现业务间的隔离.
    // 创建一个调度器
    co::Scheduler* sched = co::Scheduler::Create();
    // 启动4个线程执行新创建的调度器
    std::thread t2([sched]{ sched->Start(4); });
    t2.detach();
    // 在新创建的调度器上创建一个协程
    go co_scheduler(sched) []{
        printf("run in my scheduler.\n");
    };
    co_sleep(100);
    return 0;
}

/************************************************
 * libgo库原生提供了一个线程安全的定时器
 * 还提供了休眠当前协程的方法co_sleep，类似于系统调用sleep, 不过时间单
 * 位是毫秒.
 * 同时HOOK了系统调用sleep、usleep、nanosleep, 在协程中使用这几个系统
 * 调用, 会在等待期间让出cpu控制权, 执行其他协程, 不会阻塞调度线程.
************************************************/
#include <libgo/coroutine.h>
int main()
{
    // 创建一个定时器
    // 第一个参数: 精度
    // 第二个参数: 绑定到一个调度器(Scheduler)
    // 两个参数都有默认值, 可以简便地创建一个定时器: co_timer timer; 
    co_timer timer(std::chrono::milliseconds(1), &co_sched);
    // 使用timer.ExpireAt接口设置一个定时任务
    // 第一个参数可以是std::chrono中的时间长度，也可以是时间点。
    // 第二个参数是定时器回调函数
    // 返回一个co_timer_id类型的ID, 通过这个ID可以撤销还未执行的定时函数
    co_timer_id id1 = timer.ExpireAt(std::chrono::seconds(1), []{
            printf("Timer Callback.\n");
            });
    // co_timer_id::StopTimer接口可以撤销还未开始执行的定时函数
    // 它返回bool类型的结果，如果撤销成功，返回true；
    //     如果未来得及撤销，返回false, 此时不保证回调函数已执行完毕。
    bool cancelled = id1.StopTimer();
    printf("cancelled:%s\n", cancelled ? "true" : "false");
    timer.ExpireAt(std::chrono::seconds(2), [&]{
            printf("Timer Callback.\n");
            co_sched.Stop();
            });
    for (int i = 0; i < 100; ++i)
        go []{
            // 休眠当前协程 1000 milliseconds.
            // 不会阻塞线程, 因此100个并发的休眠, 总共只需要1秒.
            co_sleep(1000);
        };
#if !defined(_WIN32)
    // 系统调用提供的sleep usleep nanosleep都使用HOOK技术,
    // 使其在协程中运行时, 能达到和co_sleep相同的效果.
    go []{
        // 休眠当前协程 1 second
        sleep(1);
    };
    go []{
        // 休眠当前协程 100 milliseconds
        usleep(100 * 1000);
    };
#endif
    co_sched.Start();
    return 0;
}

-D CMAKE_CXX_FLAGS="/utf-8"

if(MSVC)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /utf-8")
endif()

git config --global core.autocrlf true

libgo.lib(processer.cpp.obj) : error LNK2019: unresolved external symbol __imp__WSASetLastError@4

cmake_minimum_required(VERSION 3.12)
project(untitled VERSION 0.0.1)
set(CMAKE_CXX_STANDARD 11)
set(BUILD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/build)
set(STATIC_LIB_DIR ${CMAKE_CURRENT_SOURCE_DIR}/lib)
set(SRC_PATH
        ${CMAKE_CURRENT_SOURCE_DIR}/src
        )
include_directories(
        ${SRC_PATH}
        ${CMAKE_CURRENT_SOURCE_DIR}/include
)
add_definitions(
)
if(MSVC)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /utf-8")
endif()
####################  scan source files ####################
foreach (path ${SRC_PATH})
    aux_source_directory(${path} SRC_FILES)
endforeach ()
link_libraries(ws2_32)
add_executable(${PROJECT_NAME} ${SRC_FILES} )
set(LIBGO_LIB ${STATIC_LIB_DIR}/libgo.lib)
target_link_libraries(${PROJECT_NAME} PRIVATE ${LIBGO_LIB} )
#find_package(libgo CONFIG REQUIRED)
#target_link_libraries(${PROJECT_NAME} PRIVATE libgo::libgo)