c_wcf_internal.h

Go to the documentation of this file.

#pragma once
#include <algorithm>
#include <vector>
#include "webcface/common/internal/safe_global.h"
#include "webcface/wcf.h"
#include "webcface/client.h"
#include "webcface/func.h"
#include "webcface/components.h"
#include "webcface/common/val_adaptor.h"
 
WEBCFACE_NS_BEGIN
inline namespace c_wcf {
template <typename CharT>
inline std::basic_string_view<CharT> strOrEmpty(const CharT *p) {
    if (p) {
        return p;
    } else {
        return std::basic_string_view<CharT>();
    }
}
 
inline internal::SafeGlobal<
    std::unordered_map<const wcfFuncCallHandle *, FuncCallHandle>>
    fetched_handles;
inline internal::SafeGlobal<
    std::unordered_map<const wcfFuncCallHandleW *, FuncCallHandle>>
    fetched_handles_w;
 
inline internal::SafeGlobal<std::unordered_map<const wcfMultiVal *, ValAdaptor>>
    func_val_list;
inline internal::SafeGlobal<
    std::unordered_map<const wcfMultiValW *, ValAdaptor>>
    func_val_list_w;
 
inline internal::SafeGlobal<std::unordered_map<
    const wcfViewComponent *, const std::vector<ViewComponent>>>
    view_list;
inline internal::SafeGlobal<std::unordered_map<
    const wcfViewComponentW *, const std::vector<ViewComponent>>>
    view_list_w;
 
template <typename CharT>
struct CharType {};
template <>
struct CharType<char> {
    using CVal = wcfMultiVal;
    using CHandle = wcfFuncCallHandle;
    using CCallback = wcfFuncCallback;
    using CEventCallback1 = wcfEventCallback1;
    using CEventCallback2 = wcfEventCallback2;
    using CComponent = wcfViewComponent;
    static constexpr auto &fetchedHandles() { return fetched_handles; }
    static constexpr auto &funcValList() { return func_val_list; }
    static constexpr auto &viewList() { return view_list; }
};
template <>
struct CharType<wchar_t> {
    using CVal = wcfMultiValW;
    using CHandle = wcfFuncCallHandleW;
    using CCallback = wcfFuncCallbackW;
    using CEventCallback1 = wcfEventCallback1W;
    using CEventCallback2 = wcfEventCallback2W;
    using CComponent = wcfViewComponentW;
    static constexpr auto &fetchedHandles() { return fetched_handles_w; }
    static constexpr auto &funcValList() { return func_val_list_w; }
    static constexpr auto &viewList() { return view_list_w; }
};
 
inline internal::SafeGlobal<std::vector<wcfClient *>> wcli_list;
 
inline internal::SafeGlobal<std::vector<Promise *>> func_result_list;
 
inline Client *getWcli(wcfClient *wcli) {
    if (!wcli_list) {
        return nullptr;
    }
    if (std::find(wcli_list->begin(), wcli_list->end(), wcli) ==
        wcli_list->end()) {
        return nullptr;
    }
    return static_cast<Client *>(wcli);
}
 
inline Promise *getPromise(wcfPromise *res) {
    if (!func_result_list) {
        return nullptr;
    }
    if (std::find(func_result_list->begin(), func_result_list->end(), res) ==
        func_result_list->end()) {
        return nullptr;
    }
    return static_cast<Promise *>(res);
}
 
template <typename MultiVal>
ValAdaptor fromCVal(const MultiVal &val) {
    if (val.as_str != nullptr) {
        return ValAdaptor(val.as_str);
    } else if (val.as_double != 0) {
        return ValAdaptor(val.as_double);
    } else {
        return ValAdaptor(val.as_int);
    }
}
template <typename CharT>
std::vector<ValAdaptor> argsFromCVal(const typename CharType<CharT>::CVal *args,
                                     int arg_size) {
    std::vector<ValAdaptor> args_v;
    args_v.reserve(arg_size);
    for (int i = 0; i < arg_size; i++) {
        args_v.emplace_back(fromCVal(args[i]));
    }
    return args_v;
}
 
template <typename CharT>
auto resultToCVal(const ValAdaptor &result_val) {
    auto result = new typename CharType<CharT>::CVal();
    auto &list = CharType<CharT>::funcValList();
    if(list){
        list->emplace(result, result_val);
        const ValAdaptor &result_val_ref =
            list->at(result);
        result->as_int = result_val_ref;
        result->as_double = result_val_ref;
        if constexpr (std::is_same_v<CharT, char>) {
            result->as_str = result_val_ref.asStringView().c_str();
        } else {
            result->as_str = result_val_ref.asWStringView().c_str();
        }
    }
    return result;
}
 
} // namespace c_wcf
WEBCFACE_NS_END
 
using namespace webcface;