#include "co/god.h"

void f() {
    god::bless_no_bugs();
    god::is_same<T, int, bool>(); // T is int or bool?
}

#include "co/flag.h"
#include "co/cout.h"

DEF_bool(x, false, "x");
DEF_bool(y, true, "y");
DEF_bool(debug, false, "dbg", d);
DEF_uint32(u, 0, "xxx");
DEF_string(s, "", "xx");

int main(int argc, char** argv) {
    flag::parse(argc, argv);
    cout << "x: " << FLG_x << '\n';
    cout << "y: " << FLG_y << '\n';
    cout << "debug: " << FLG_debug << '\n';
    cout << "u: " << FLG_u << '\n';
    cout << FLG_s << "|" << FLG_s.size() << '\n';
    return 0;
}

./xx                  # Run with default configs
./xx -x -s good       # x -> true, s -> "good"
./xx -debug           # debug -> true
./xx -xd              # x -> true, debug -> true
./xx -u 8k ### u -> 8192

./xx -mkconf          # Автоматически создать конфигурационный файл: xx.conf
./xx xx.conf          # запустить с конфигурационным файлом
./xx -conf xx.conf    # То же, что и выше

#include "co/log.h"

int main(int argc, char** argv) {
    flag::parse(argc, argv);

    TLOG("xx") << "s" << 23; // тематический журнал
    DLOG << "hello " << 23;  // отладка
    LOG << "hello " << 23;   // информация
    WLOG << "hello " << 23;  // предупреждение
    ELOG << "hello " << 23;  // ошибка
    FLOG << "hello " << 23;  // фатальный

    return 0;
}

void* p = malloc(32);
CHECK(p != NULL) << "malloc failed..";
CHECK_NE(p, NULL) << "malloc failed..";

#include "co/unitest.h"
#include "co/os.h"

DEF_test(os) {
    DEF_case(homedir) {
        EXPECT_NE(os::homedir(), "");
    }

    DEF_case(cpunum) {
        EXPECT_GT(os::cpunum(), 0);
    }
}
 
int main(int argc, char** argv) {
    flag::parse(argc, argv);
    unitest::run_tests();
    return 0;
}

xmake r unitest      # Запустить все тестовые примеры
xmake r unitest -os  # Запустить тестовые примеры в модуле os

// {"a":23,"b":false,"s":"123","v":[1,2,3],"o":{"xx":0}}
co::Json x = {
    { "a", 23 },
    { "b", false },
    { "s", "123" },
    { "v", {1,2,3} },
    { "o", {
        {"xx", 0}
    }},
};

// equal to x
co::Json y = Json()
    .add_member("a", 23)
    .add_member("b", false)
    .add_member("s", "123")
    .add_member("v", Json().push_back(1).push_back(2).push_back(3))
    .add_member("o", Json().add_member("xx", 0));

x.get("a").as_int();       // 23
x.get("s").as_string();    // "123"
x.get("s").as_int();       // 123, string -> int
x.get("v", 0).as_int();    // 1
x.get("v", 2).as_int();    // 3 **x.get("o", "xx").as_int(); // 0**

**x["a"] == 23;          // true**
**x["s"] == "123";       // true**
**x.get("o", "xx") != 0; // false**

#include "co/co.h"

int main(int argc, char** argv) {
    flag::parse(argc, argv);

    co::wait_group wg;
    wg.add(2);

    go([wg](){
        LOG << "hello world";
        wg.done();
    });

    go([wg](){
        LOG << "hello again";
        wg.done();
    });

    wg.wait();
    return 0;
}

// запустить f1 и f2 в одном планировщике
auto s = co::next_sched();
s->go(f1);
s->go(f2);

// запустить f во всех планировщиках
for (auto& s : co::scheds()) {
    s->go(f);
}

#include "co/co.h"
#include "co/rpc.h"
#include "co/time.h"

int main(int argc, char** argv) {
    flag::parse(argc, argv);

    rpc::Server()
        .add_service(new xx::HelloWorldImpl)
        .start("127.0.0.1", 7788, "/xx");

    for (;;) sleep::sec(80000);
    return 0;
}

curl http://127.0.0.1:7788/xx --request POST --data '{"api":"ping"}'

#include "co/flag.h"
#include "co/http.h"

DEF_string(d, ".", "root dir"); // docroot for the web server

int main(int argc, char** argv) {
    flag::parse(argc, argv);
    so::easy(FLG_d.c_str()); // mum never have to worry again
    return 0;
}

void cb(const http::Req& req, http::Res& res) {
    if (req.is_method_get()) {
        if (req.url() == "/hello") {
            res.set_status(200);
            res.set_body("hello world");
        } else {
            res.set_status(404);
        }
    } else {
        res.set_status(405); // method not allowed
    }
}

// http
http::Server().on_req(cb).start("0.0.0.0", 80);

// https
http::Server().on_req(cb).start(
    "0.0.0.0", 443, "privkey.pem", "certificate.pem"
);

void f() {
    http::Client c("https://github.com");

    c.get("/");
    LOG << "response code: "<< c.status();
    LOG << "body size: "<< c.body().size();
    LOG << "Content-Length: "<< c.header("Content-Length");
    LOG << c.header();
``` **Код композиции**

- include — заголовочные файлы coost.
- src — исходные файлы coost, собранные как libco.
- test — тестовый код, каждый файл .cc будет скомпилирован в отдельную тестовую программу.
- unitest — код модульного теста, каждый файл .cc соответствует отдельному тестовому блоку, и весь код будет скомпилирован в одну тестовую программу.
- gen — генератор кода для RPC-фреймворка.

**Сборка**

5.1. Необходимые компиляторы

Для сборки coost нужен компилятор, поддерживающий C++11:

* Linux: gcc 4.8+.
* Mac: clang 3.3+.
* Windows: vs2015+.

5.2. Сборка с помощью xmake

coost рекомендует использовать xmake в качестве инструмента сборки.

5.2.1 Быстрый старт

```sh
# Все команды выполняются в корневом каталоге coost (то же самое ниже)
xmake      # по умолчанию сборка libco
xmake -a   # сборка всех проектов (libco, gen, test, unitest)

xmake f -k shared
xmake -v

xmake f -p mingw
xmake -v

xmake f --with_libcurl=true --with_openssl=true
xmake -v

# По умолчанию устанавливаются файлы заголовков и libco.
xmake install -o pkg         # упаковать связанные файлы в каталог pkg
xmake i -o pkg               # то же, что и выше
xmake install -o /usr/local  # установить в каталог /usr/local

xrepo install -f "openssl=true,libcurl=true" coost

mkdir build && cd build
cmake ..
make -j8

mkdir build && cd build
cmake .. -DBUILD_ALL=ON
make -j8

mkdir build && cd build
cmake .. -DWITH_LIBCURL=ON -DWITH_OPENSSL=ON
make -j8

cmake .. -DBUILD_SHARED_LIBS=ON
make -j8

find_package(coost REQUIRED CONFIG)
target_link_libraries(userTarget coost::co)

vcpkg install coost:x64-windows

# Поддержка HTTP & SSL
vcpkg install coost[libcurl,openssl]:x64-windows

conan install coost