README.md

@@ -30,7 +30,8 @@ project/
 │   │   │   └── ProxyMarshaller.h
 │   │   └── rpc
 │   │       ├── rpc_export.h
-│   │       └── RpcInvoker.h
+│   │       ├── RpcInvoker.h
+│   │       └── RpcSerializer.h
 │   ├── MyService.cpp
 │   ├── MyService.h
 │   └── server.cpp

include/proxy/ProxyMarshaller.h

@@ -1,42 +1,27 @@
 #pragma once
 
 #include <ipc/IpcChannel.h>
-#include <rpc/RpcValue.h>
 
 class ProxyMarshaller {
 public:
     explicit ProxyMarshaller(IpcChannel& ch) : channel(ch) {}
 
-    // Базовый type-erased вызов: принимает вектор RpcValue и возвращает RpcValue.
+    template<typename Ret, typename... Args>
-    RpcValue call(const std::string& method, const RpcArgs& args) {
+    Ret call(const std::string& method, const Args&... args) {
         IpcMessage msg;
 
         // имя метода
         msg.add(method);
 
-        // аргументы (PoC: только int)
+        // аргументы
-        for (const auto& a : args) {
+        (msg.add(args), ...);
-            msg.add(a.asInt());
-        }
 
         // отправить
         channel.send(msg);
 
         // получить ответ
         IpcMessage resp = channel.receive();
-        return RpcValue::fromInt(resp.get<int>());
+        return resp.template get<Ret>();
-    }
-
-    // Удобный шаблонный хелпер для сгенерированных прокси.
-    template<typename Ret, typename... Args>
-    Ret callTyped(const std::string& method, const Args&... args) {
-        RpcArgs packed;
-        packed.reserve(sizeof...(Args));
-        (packed.emplace_back(RpcValue::fromInt(args)), ...); // PoC: только int
-
-        RpcValue r = call(method, packed);
-        // PoC: Ret == int
-        return static_cast<Ret>(r.asInt());
     }
 
 private:

include/rpc/RpcInvoker.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <rpc/RpcValue.h>
+#include <ipc/IpcMessage.h>
 
 #include <functional>
 #include <string>
@@ -14,42 +14,50 @@ public:
                         const std::string& name,
                         Ret (Obj::*method)(Args...)) {
         handlers[name] =
-            [instance, method](const RpcArgs& args) -> RpcValue {
+            [instance, method](const IpcMessage& req) -> IpcMessage {
-                auto tuple = readArgs<Args...>(args);
+                IpcMessage msg = req;
-                Ret result = std::apply(
-                    method, std::tuple_cat(std::make_tuple(instance), tuple));
 
-                // PoC: считаем, что Ret == int.
+                // пропустить имя метода
-                return RpcValue::fromInt(result);
+                (void)msg.template get<std::string>();
+
+                // читать аргументы и вызвать метод
+                return callMethod<Ret, Obj, Args...>(instance, method, msg);
             };
     }
 
-    RpcValue dispatch(const std::string& method, const RpcArgs& args) const {
+    IpcMessage dispatch(const IpcMessage& request) {
+        IpcMessage tmp = request;
+        const std::string method = tmp.get<std::string>();
+
         auto it = handlers.find(method);
         if (it == handlers.end()) {
-            // PoC: в случае ошибки возвращаем 0.
+            return IpcMessage{};
-            return RpcValue::fromInt(0);
         }
 
-        return it->second(args);
+        return it->second(request);
     }
 
 private:
-    template<typename... Args, std::size_t... I>
+    template<typename Ret, typename Obj, typename... Args>
-    static std::tuple<Args...>
+    static IpcMessage callMethod(Obj* obj,
-    readArgsImpl(const RpcArgs& args, std::index_sequence<I...>) {
+                                 Ret (Obj::*method)(Args...),
-        return std::tuple<Args...>{
+                                 IpcMessage& msg) {
-            static_cast<Args>(args[I].asInt())...}; // PoC: только int
+        auto tuple = readArgs<Args...>(msg);
+        Ret result =
+            std::apply(method, std::tuple_cat(std::make_tuple(obj), tuple));
+
+        IpcMessage out;
+        out.add(result);
+        return out;
     }
 
     template<typename... Args>
-    static std::tuple<Args...> readArgs(const RpcArgs& args) {
+    static std::tuple<Args...> readArgs(IpcMessage& msg) {
-        return readArgsImpl<Args...>(
+        return std::tuple<Args...>{msg.template get<Args>()...};
-            args, std::make_index_sequence<sizeof...(Args)>{});
     }
 
     std::unordered_map<std::string,
-                       std::function<RpcValue(const RpcArgs&)>>
+                       std::function<IpcMessage(const IpcMessage&)>>
         handlers;
 };
 

include/rpc/RpcSerializer.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <sstream>
+#include <string>
+
+class RpcSerializer {
+public:
+    template<typename T>
+    static void write(std::ostringstream& out, const T& v) {
+        out << v << ' ';
+    }
+
+    template<typename T>
+    static T read(std::istringstream& in) {
+        T v;
+        in >> v;
+        return v;
+    }
+};
+
+

include/rpc/RpcValue.h

@@ -1,38 +0,0 @@
-#pragma once
-
-#include <vector>
-
-// Простейшее type-erased значение для RPC.
-// PoC: поддерживаем только int, но интерфейс позволяет в будущем
-// добавить другие типы (string, bool, и т.д.).
-
-enum class RpcType {
-    Int,
-};
-
-class RpcValue {
-public:
-    RpcValue() : type_(RpcType::Int), i_(0) {}
-
-    static RpcValue fromInt(int v) {
-        RpcValue r;
-        r.type_ = RpcType::Int;
-        r.i_ = v;
-        return r;
-    }
-
-    RpcType type() const { return type_; }
-
-    int asInt() const {
-        // PoC: единственный поддерживаемый тип.
-        return i_;
-    }
-
-private:
-    RpcType type_;
-    int i_;
-};
-
-using RpcArgs = std::vector<RpcValue>;
-
-

tools/templates/proxy.cpp.j2

@@ -5,7 +5,7 @@
 
 {% for m in cls.methods %}
 {{ m.return_type }} {{ cls.name }}Proxy::{{ m.name }}({% for a in m.args %}{{ a.type }} {{ a.name }}{% if not loop.last %}, {% endif %}{% endfor %}) {
-    return impl.callTyped<{{ m.return_type }}>("{{ cls.name }}.{{ m.name }}"{% for a in m.args %}, {{ a.name }}{% endfor %});
+    return impl.call<{{ m.return_type }}>("{{ cls.name }}.{{ m.name }}"{% for a in m.args %}, {{ a.name }}{% endfor %});
 }
 {% endfor %}
 

tools/templates/skeleton.cpp.j2

@@ -10,23 +10,6 @@
 }
 
 IpcMessage {{ cls.name }}Skeleton::dispatch(const IpcMessage& req) {
-    // Перепаковываем IpcMessage в RpcArgs и вызываем type-erased инвокер.
+    return invoker.dispatch(req);
-    IpcMessage msg = req;
-
-    // имя метода
-    std::string method = msg.get<std::string>();
-
-    // аргументы (PoC: только int, читаем все до конца сообщения)
-    RpcArgs args;
-    while (!msg.empty()) {
-        int v = msg.get<int>();
-        args.emplace_back(RpcValue::fromInt(v));
-    }
-
-    RpcValue result = invoker.dispatch(method, args);
-
-    IpcMessage resp;
-    resp.add(result.asInt()); // PoC: только int
-    return resp;
 }