Libraries/jerryscript/src/include/Jerryscript/Context.h

Go to the documentation of this file.

/****
 * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
 * Created 2015 by Skurydin Alexey
 * http://github.com/SmingHub/Sming
 * All files of the Sming Core are provided under the LGPL v3 license.
 *
 * Context.h - Support for external contexts
 *
 * @author: Dec 2021 - Mikee47 <mike@sillyhouse.net>
 *
 */
 
#pragma once
 
#include "Function.h"
#include <Data/LinkedObjectList.h>
#include <Platform/System.h>
#include <memory>
 
#define JS_DEFINE_METHOD(method, ...)                                                                                  \
    static jerry_value_t method(const jerry_call_info_t* call_info_p, const jerry_value_t args[],                      \
                                const jerry_length_t args_count)                                                       \
    {                                                                                                                  \
        using Method = JS::Value (ContextClass::*)(const jerry_call_info_t*, ...);                                     \
        if(JS_NARG(__VA_ARGS__) != args_count) {                                                                       \
            return JS::create_arg_count_error(__FUNCTION__);                                                           \
        }                                                                                                              \
        auto& ctx = getCurrent();                                                                                      \
        auto m = reinterpret_cast<Method>(&ContextClass::js_##method);                                                 \
        auto res = (ctx.*m)(call_info_p JS_CONCAT(JS_ARGS_, JS_NARG(__VA_ARGS__)));                                    \
        return res.release();                                                                                          \
    }                                                                                                                  \
    Jerryscript::Value js_##method(const JS::CallInfo& callInfo, ##__VA_ARGS__)
 
#define JS_DEFINE_METHOD_VAR(method)                                                                                   \
    static jerry_value_t method(const jerry_call_info_t* call_info_p, const jerry_value_t args[],                      \
                                const jerry_length_t args_count)                                                       \
    {                                                                                                                  \
        using Method = JS::Value (ContextClass::*)(const jerry_call_info_t*, JS::Value[], unsigned);                   \
        auto& ctx = getCurrent();                                                                                      \
        auto m = reinterpret_cast<Method>(&ContextClass::js_##method);                                                 \
        auto res = (ctx.*m)(call_info_p, (JS::Value*)args, args_count);                                                \
        return res.release();                                                                                          \
    }                                                                                                                  \
    Jerryscript::Value js_##method(const Jerryscript::CallInfo& callInfo, Jerryscript::Value args[], unsigned argCount)
 
namespace Jerryscript
{
class Context
{
public:
    Context();
 
    Context(size_t heapSize);
 
    ~Context()
    {
        if(current == this) {
            current = nullptr;
        }
    }
 
    explicit operator bool() const
    {
        return bool(context);
    }
 
    void select()
    {
        current = this;
    }
 
    operator jerry_context_t*() const
    {
        return reinterpret_cast<jerry_context_t*>(context.get());
    }
 
    static Context& getCurrent()
    {
        assert(current != nullptr);
        return *current;
    }
 
private:
    static void* alloc(size_t size, void* param);
 
    std::unique_ptr<uint8_t[]> context;
    static Context* current;
};
 
template <class ClassType> class ContextTemplate : public LinkedObjectTemplate<ClassType>, public Context
{
public:
    using ContextClass = ClassType;
 
    using Context::Context;
 
    static ClassType& getCurrent()
    {
        return static_cast<ClassType&>(Context::getCurrent());
    }
};
 
template <class ClassType> class ContextList : public OwnedLinkedObjectListTemplate<ClassType>
{
public:
    using Callback = Delegate<void(ClassType& ctx)>;
 
    void foreach(Callback callback)
    {
        runNext(this->head(), callback);
    }
 
private:
    static void runNext(ClassType* ctx, Callback callback)
    {
        if(ctx == nullptr) {
            return;
        }
        System.queueCallback([ctx, callback]() {
            callback(*ctx);
            runNext(ctx->getNext(), callback);
        });
    }
};
 
} // namespace Jerryscript