gbe_fork/dll/callsystem.cpp

/* Copyright (C) 2019 Mr Goldberg
   This file is part of the Goldberg Emulator

   The Goldberg Emulator is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 3 of the License, or (at your option) any later version.

   The Goldberg Emulator is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the Goldberg Emulator; if not, see
   <http://www.gnu.org/licenses/>.  */

#include "dll/callsystem.h"


void CCallbackMgr::SetRegister(class CCallbackBase *pCallback, int iCallback)
{
    pCallback->m_nCallbackFlags |= CCallbackBase::k_ECallbackFlagsRegistered;
    pCallback->m_iCallback = iCallback;
};

void CCallbackMgr::SetUnregister(class CCallbackBase *pCallback)
{
    if (pCallback)
        pCallback->m_nCallbackFlags &= !CCallbackBase::k_ECallbackFlagsRegistered;
};

bool CCallbackMgr::isServer(class CCallbackBase *pCallback)
{
    return (pCallback->m_nCallbackFlags & CCallbackBase::k_ECallbackFlagsGameServer) != 0;
};



Steam_Call_Result::Steam_Call_Result(SteamAPICall_t a, int icb, void *r, unsigned int s, double r_in, bool run_cc_cb)
{
    api_call = a;
    result.resize(s);
    if (s > 0 && r != NULL) {
        memcpy(&(result[0]), r, s);
    }
    run_in = r_in;
    run_call_completed_cb = run_cc_cb;
    iCallback = icb;
    created = std::chrono::high_resolution_clock::now();
}

bool Steam_Call_Result::operator==(const struct Steam_Call_Result& other) const
{
    return other.api_call == api_call && other.callbacks == callbacks;
}

bool Steam_Call_Result::timed_out() const
{
    return check_timedout(created, STEAM_CALLRESULT_TIMEOUT);
}

bool Steam_Call_Result::call_completed() const
{
    return (!reserved) && check_timedout(created, run_in);
}

bool Steam_Call_Result::can_execute() const
{
    return (!to_delete) && call_completed() && (has_cb() || check_timedout(created, STEAM_CALLRESULT_WAIT_FOR_CB));
}

bool Steam_Call_Result::has_cb() const
{
    return callbacks.size() > 0;
}



void SteamCallResults::addCallCompleted(class CCallbackBase *cb)
{
    if (std::find(completed_callbacks.begin(), completed_callbacks.end(), cb) == completed_callbacks.end()) {
        completed_callbacks.push_back(cb);
    }
}

void SteamCallResults::rmCallCompleted(class CCallbackBase *cb)
{
    auto c = std::find(completed_callbacks.begin(), completed_callbacks.end(), cb);
    if (c != completed_callbacks.end()) {
        completed_callbacks.erase(c);
    }
}

void SteamCallResults::addCallBack(SteamAPICall_t api_call, class CCallbackBase *cb)
{
    auto cb_result = std::find_if(callresults.begin(), callresults.end(), [api_call](struct Steam_Call_Result const& item) { return item.api_call == api_call; });
    if (cb_result != callresults.end()) {
        cb_result->callbacks.push_back(cb);
        CCallbackMgr::SetRegister(cb, cb->GetICallback());
    }
}

bool SteamCallResults::exists(SteamAPICall_t api_call) const
{
    auto cr = std::find_if(callresults.begin(), callresults.end(), [api_call](struct Steam_Call_Result const& item) {
        return item.api_call == api_call;
    });
    if (callresults.end() == cr) return false;
    if (!cr->call_completed()) return false;
    return true;
}

bool SteamCallResults::callback_result(SteamAPICall_t api_call, void *copy_to, unsigned int size)
{
    auto cb_result = std::find_if(callresults.begin(), callresults.end(), [api_call](struct Steam_Call_Result const& item) {
        return item.api_call == api_call;
    });
    if (cb_result != callresults.end()) {
        if (!cb_result->call_completed()) return false;
        if (cb_result->result.size() > size) return false;

        memcpy(copy_to, &(cb_result->result[0]), cb_result->result.size());
        cb_result->to_delete = true;
        return true;
    } else {
        return false;
    }
}

void SteamCallResults::rmCallBack(SteamAPICall_t api_call, class CCallbackBase *cb)
{
    auto cb_result = std::find_if(callresults.begin(), callresults.end(), [api_call](struct Steam_Call_Result const& item) { return item.api_call == api_call; });
    if (cb_result != callresults.end()) {
        auto it = std::find(cb_result->callbacks.begin(), cb_result->callbacks.end(), cb);
        if (it != cb_result->callbacks.end()) {
            cb_result->callbacks.erase(it);
            CCallbackMgr::SetUnregister(cb);
        }
    }
}

void SteamCallResults::rmCallBack(class CCallbackBase *cb)
{
    //TODO: check if callback is callback or call result?
    for (auto & cr: callresults) {
        auto it = std::find(cr.callbacks.begin(), cr.callbacks.end(), cb);
        if (it != cr.callbacks.end()) {
            cr.callbacks.erase(it);
        }

        if (cr.callbacks.size() == 0) {
            cr.to_delete = true;
        }
    }
}

SteamAPICall_t SteamCallResults::addCallResult(SteamAPICall_t api_call, int iCallback, void *result, unsigned int size, double timeout, bool run_call_completed_cb)
{
    PRINT_DEBUG("%i", iCallback);
    auto cb_result = std::find_if(callresults.begin(), callresults.end(), [api_call](struct Steam_Call_Result const& item) { return item.api_call == api_call; });
    if (cb_result != callresults.end()) {
        if (cb_result->reserved) {
            std::chrono::high_resolution_clock::time_point created = cb_result->created;
            std::vector<class CCallbackBase *> temp_cbs = cb_result->callbacks;
            *cb_result = Steam_Call_Result(api_call, iCallback, result, size, timeout, run_call_completed_cb);
            cb_result->callbacks = temp_cbs;
            cb_result->created = created;
            return cb_result->api_call;
        }
    } else {
        struct Steam_Call_Result res = Steam_Call_Result(api_call, iCallback, result, size, timeout, run_call_completed_cb);
        callresults.push_back(res);
        return callresults.back().api_call;
    }

    PRINT_DEBUG("ERROR");
    return k_uAPICallInvalid;
}

SteamAPICall_t SteamCallResults::reserveCallResult()
{
    struct Steam_Call_Result res = Steam_Call_Result(generate_steam_api_call_id(), 0, NULL, 0, 0.0, true);
    res.reserved = true;
    callresults.push_back(res);
    return callresults.back().api_call;
}

SteamAPICall_t SteamCallResults::addCallResult(int iCallback, void *result, unsigned int size, double timeout, bool run_call_completed_cb)
{
    return addCallResult(generate_steam_api_call_id(), iCallback, result, size, timeout, run_call_completed_cb);
}

void SteamCallResults::setCbAll(void (*cb_all)(std::vector<char> result, int callback))
{
    this->cb_all = cb_all;
}

void SteamCallResults::runCallResults()
{
    unsigned long current_size = callresults.size();
    for (unsigned i = 0; i < current_size; ++i) {
        unsigned index = i;

        if (!callresults[index].to_delete) {
            if (callresults[index].can_execute()) {
                std::vector<char> result = callresults[index].result;
                SteamAPICall_t api_call = callresults[index].api_call;
                bool run_call_completed_cb = callresults[index].run_call_completed_cb;
                int iCallback = callresults[index].iCallback;
                if (run_call_completed_cb) {
                    callresults[index].run_call_completed_cb = false;
                }

                callresults[index].to_delete = true;
                if (callresults[index].has_cb()) {
                    std::vector<class CCallbackBase *> temp_cbs = callresults[index].callbacks;
                    for (auto & cb : temp_cbs) {
                        PRINT_DEBUG("Calling callresult %p %i", cb, cb->GetICallback());
                        global_mutex.unlock();
                        //TODO: unlock relock doesn't work if mutex was locked more than once.
                        if (run_call_completed_cb) { //run the right function depending on if it's a callback or a call result.
                            cb->Run(&(result[0]), false, api_call);
                        } else {
                            cb->Run(&(result[0]));
                        }
                        //COULD BE DELETED SO DON'T TOUCH CB
                        global_mutex.lock();
                        PRINT_DEBUG("callresult done");
                    }
                }

                if (run_call_completed_cb) {
                    //can it happen that one is removed during the callback?
                    std::vector<class CCallbackBase *> callbacks = completed_callbacks;
                    SteamAPICallCompleted_t data{};
                    data.m_hAsyncCall = api_call;
                    data.m_iCallback = iCallback;
                    data.m_cubParam = result.size();

                    for (auto & cb: callbacks) {
                        PRINT_DEBUG("Call complete cb %i %p %llu", iCallback, cb, api_call);
                        //TODO: check if this is a problem or not.
                        SteamAPICallCompleted_t temp = data;
                        global_mutex.unlock();
                        cb->Run(&temp);
                        global_mutex.lock();
                    }

                    if (cb_all) {
                        std::vector<char> res;
                        res.resize(sizeof(data));
                        memcpy(&(res[0]), &data, sizeof(data));
                        cb_all(res, data.k_iCallback);
                    }
                } else {
                    if (cb_all) {
                        cb_all(result, iCallback);
                    }
                }
            } else {
                if (callresults[index].timed_out()) {
                    callresults[index].to_delete = true;
                }
            }
        }
    }

    PRINT_DEBUG("erase to_delete");
    auto c = std::begin(callresults);
    while (c != std::end(callresults)) {
        if (c->to_delete) {
            if (c->timed_out()) {
                PRINT_DEBUG("removed callresult %i", c->iCallback);
                c = callresults.erase(c);
            } else {
                ++c;
            }
        } else {
            ++c;
        }
    }
}



SteamCallBacks::SteamCallBacks(SteamCallResults *results)
{
    this->results = results;
}

void SteamCallBacks::addCallBack(int iCallback, class CCallbackBase *cb)
{
    PRINT_DEBUG("%i", iCallback);
    if (iCallback == SteamAPICallCompleted_t::k_iCallback) {
        results->addCallCompleted(cb);
        CCallbackMgr::SetRegister(cb, iCallback);
        return;
    }

    if (std::find(callbacks[iCallback].callbacks.begin(), callbacks[iCallback].callbacks.end(), cb) == callbacks[iCallback].callbacks.end()) {
        callbacks[iCallback].callbacks.push_back(cb);
        CCallbackMgr::SetRegister(cb, iCallback);
        for (auto & res: callbacks[iCallback].results) {
            //TODO: timeout?
            SteamAPICall_t api_id = results->addCallResult(iCallback, &(res[0]), res.size(), 0.0, false);
            results->addCallBack(api_id, cb);
        }
    }
}

void SteamCallBacks::addCBResult(int iCallback, void *result, unsigned int size, double timeout, bool dont_post_if_already)
{
    if (dont_post_if_already) {
        for (auto & r : callbacks[iCallback].results) {
            if (r.size() == size) {
                if (memcmp(&(r[0]), result, size) == 0) {
                    //cb already posted
                    return;
                }
            }
        }
    }

    std::vector<char> temp{};
    temp.resize(size);
    memcpy(&(temp[0]), result, size);
    callbacks[iCallback].results.push_back(temp);
    for (auto cb: callbacks[iCallback].callbacks) {
        SteamAPICall_t api_id = results->addCallResult(iCallback, result, size, timeout, false);
        results->addCallBack(api_id, cb);
    }

    if (callbacks[iCallback].callbacks.empty()) {
        results->addCallResult(iCallback, result, size, timeout, false);
    }
}

void SteamCallBacks::addCBResult(int iCallback, void *result, unsigned int size)
{
    addCBResult(iCallback, result, size, DEFAULT_CB_TIMEOUT, false);
}

void SteamCallBacks::addCBResult(int iCallback, void *result, unsigned int size, bool dont_post_if_already)
{
    addCBResult(iCallback, result, size, DEFAULT_CB_TIMEOUT, dont_post_if_already);
}

void SteamCallBacks::addCBResult(int iCallback, void *result, unsigned int size, double timeout)
{
    addCBResult(iCallback, result, size, timeout, false);
}

void SteamCallBacks::rmCallBack(int iCallback, class CCallbackBase *cb)
{
    if (iCallback == SteamAPICallCompleted_t::k_iCallback) {
        results->rmCallCompleted(cb);
        CCallbackMgr::SetUnregister(cb);
        return;
    }

    auto c = std::find(callbacks[iCallback].callbacks.begin(), callbacks[iCallback].callbacks.end(), cb);
    if (c != callbacks[iCallback].callbacks.end()) {
        callbacks[iCallback].callbacks.erase(c);
        CCallbackMgr::SetUnregister(cb);
        results->rmCallBack(cb);
    }
}

void SteamCallBacks::runCallBacks()
{
    for (auto & c : callbacks) {
        c.second.results.clear();
    }
}



void RunEveryRunCB::add(void (*cb)(void *object), void *object)
{
    remove(cb, object);
    RunCBs rcb;
    rcb.function = cb;
    rcb.object = object;
    cbs.push_back(rcb);
}

void RunEveryRunCB::remove(void (*cb)(void *object), void *object)
{
    auto c = std::begin(cbs);
    while (c != std::end(cbs)) {
        if (c->function == cb && c->object == object) {
            c = cbs.erase(c);
        } else {
            ++c;
        }
    }
}

void RunEveryRunCB::run() const
{
    std::vector<struct RunCBs> temp_cbs = cbs;
    for (auto c : temp_cbs) {
        c.function(c.object);
    }
}