remote.h

Go to the documentation of this file.

#pragma once
 
#include "fl/stl/json.h"
#include "fl/stl/stdint.h"
#include "fl/stl/cstddef.h"
#include "fl/stl/move.h"
#include "fl/stl/string.h"
#include "fl/stl/unordered_map.h"
#include "fl/stl/vector.h"
#include "fl/stl/strstream.h"  // IWYU pragma: keep
#include "fl/remote/rpc/rpc.h"
#include "fl/remote/rpc/rpc_mode.h"
#include "fl/remote/rpc/server.h"
#include "fl/remote/types.h"
#include "fl/net/rpc_scheduler.h"
#include "fl/stl/noexcept.h"
 
namespace fl {
 
// Forward declarations
class ResponseSend;

class Remote : public Server {
public:
    template<typename Callable>
    using Config = typename fl::Rpc::Config<Callable>;
 
    // Import types from various sources
    using RpcResult = fl::RpcResult;      // from fl/remote/types.h
    using ClearFlags = fl::RemoteClearFlags;    // from fl/remote/types.h
    using MethodInfo = fl::MethodInfo;    // from fl/remote/rpc/rpc.h
    using ParamInfo = fl::ParamInfo;      // from fl/remote/rpc/rpc.h

    Remote(RequestSource source, ResponseSink sink);
 
    // Non-copyable, non-movable (lambda captures 'this')
    Remote(const Remote&) FL_NOEXCEPT = delete;
    Remote(Remote&&) FL_NOEXCEPT = delete;
    Remote& operator=(const Remote&) FL_NOEXCEPT = delete;
    Remote& operator=(Remote&&) FL_NOEXCEPT = delete;
 
    // =========================================================================
    // Method Registration
    // =========================================================================

    template<typename Callable>
    void bind(const Config<Callable>& config) {
        mRpc.bind(config);
    }

    template<typename Callable>
    void bind(const char* name, Callable fn, fl::RpcMode mode = fl::RpcMode::SYNC) {
        bind(fl::Rpc::Config<Callable>{name, fl::move(fn), mode});
    }

    void bindAsync(const char* name,
                   fl::function<void(fl::ResponseSend&, const fl::json&)> fn,
                   fl::RpcMode mode = fl::RpcMode::ASYNC) {
        mRpc.bindAsync(name, fl::move(fn), mode);
    }

    template<class Sig>
    fl::BindResult<Sig> get(const char* name) const {
        return mRpc.get<Sig>(name);
    }

    bool has(const fl::string& name) const;

    bool unbind(const fl::string& name);
 
    // =========================================================================
    // RPC Processing
    // =========================================================================

    fl::json processRpc(const fl::json& request);
 
    // =========================================================================
    // Server Coordination
    // =========================================================================

    size_t update(u32 currentTimeMs);

    size_t tick(u32 currentTimeMs);
 
    // Note: pull() and push() inherited from Server<fl::json, fl::json>
 
    // =========================================================================
    // Results and State
    // =========================================================================

    size_t pendingCount() const;

    void clear(ClearFlags flags);
 
    // =========================================================================
    // Schema
    // =========================================================================

    fl::vector<MethodInfo> methods() const;

    fl::json schema() const {
        return mRpc.schema();
    }

    fl::size count() const {
        return mRpc.count();
    }
 
    // =========================================================================
    // Async Response Support
    // =========================================================================

    void sendAsyncResponse(const char* method, const fl::json& result);

    void sendStreamUpdate(const char* method, const fl::json& update);

    void sendStreamFinal(const char* method, const fl::json& result);
 
    // =========================================================================
    // Error Reporting (Unsolicited Notifications)
    // =========================================================================

    void reportError(const fl::string& message);

    void reportError(const fl::json& data);
 
protected:
    // Storage for async request IDs (method name -> request ID)
    struct AsyncRequest {
        int requestId;
        u32 timestamp;
    };
    fl::unordered_map<fl::string, AsyncRequest> mAsyncRequests;
    void scheduleFunction(u32 timestamp, u32 receivedAt, const fl::json& jsonRpcRequest);
    void recordResult(const fl::string& funcName, const fl::json& result, u32 scheduledAt, u32 receivedAt, u32 executedAt, bool wasScheduled);
 
    // Method registry and execution
    fl::Rpc mRpc;
 
    // Generic task scheduler
    fl::net::RpcScheduler<> mScheduler;
 
    // RPC-specific result tracking
    fl::vector<RpcResult> mResults;
 
    // Note: mRequestSource, mResponseSink, mOutgoingQueue inherited from Server
};
 
} // namespace fl