include/ipc/IpcCodec.h

@@ -1,61 +0,0 @@
-#pragma once
-
-#include <ipc/IpcMessage.h>
-#include <rpc/RpcValue.h>
-
-#include <string>
-
-// Кодек, который знает, как упаковать/распаковать RPC-запросы/ответы
-// в/IpcMessage. Живёт в IPC-слое, но опирается на типы RPC-ядра
-// (RpcValue/RpcArgs).
-namespace IpcCodec {
-
-// Запрос: имя метода + вектор аргументов.
-inline IpcMessage encodeRequest(const std::string& method,
-                                const RpcArgs& args) {
-    IpcMessage msg;
-
-    // имя метода
-    msg.add(method);
-
-    // аргументы (PoC: только int)
-    for (const auto& a : args) {
-        msg.add(a.asInt());
-    }
-
-    return msg;
-}
-
-inline void decodeRequest(const IpcMessage& msg,
-                          std::string& method,
-                          RpcArgs& args) {
-    IpcMessage copy = msg;
-
-    // имя метода
-    method = copy.get<std::string>();
-
-    // аргументы (PoC: только int, читаем до конца сообщения)
-    args.clear();
-    while (!copy.empty()) {
-        int v = copy.get<int>();
-        args.emplace_back(RpcValue::fromInt(v));
-    }
-}
-
-// Ответ: одно RpcValue (PoC: считаем, что это int).
-inline IpcMessage encodeResponse(const RpcValue& result) {
-    IpcMessage msg;
-    msg.add(result.asInt()); // PoC: только int
-    return msg;
-}
-
-inline RpcValue decodeResponse(const IpcMessage& msg) {
-    IpcMessage copy = msg;
-    int v = copy.get<int>();
-    return RpcValue::fromInt(v);
-}
-
-} // namespace IpcCodec
-
-
-

include/ipc/IpcDispatcher.h

@@ -1,47 +0,0 @@
-#pragma once
-
-#include <ipc/IpcChannel.h>
-#include <ipc/IpcCodec.h>
-#include <rpc/RpcInvoker.h>
-
-#include <string>
-
-// Серверный диспетчер, который получает IpcMessage с канала,
-// декодирует его в RPC-вызов, вызывает RpcInvoker и шлёт ответ.
-class IpcDispatcher {
-public:
-    IpcDispatcher(IpcChannel& ch, RpcInvoker& invoker)
-        : channel_(ch)
-        , invoker_(invoker) {}
-
-    // Обработать один запрос. Возвращает false, если получили "пустое"
-    // сообщение и цикл стоит завершить.
-    bool handleOnce() {
-        IpcMessage req = channel_.receive();
-        if (req.empty()) {
-            return false;
-        }
-
-        std::string method;
-        RpcArgs args;
-        IpcCodec::decodeRequest(req, method, args);
-
-        RpcValue result = invoker_.dispatch(method, args);
-        IpcMessage resp = IpcCodec::encodeResponse(result);
-        channel_.send(resp);
-        return true;
-    }
-
-    // Простой цикл обработки до тех пор, пока канал не вернёт пустое сообщение.
-    void loop() {
-        while (handleOnce()) {
-        }
-    }
-
-private:
-    IpcChannel& channel_;
-    RpcInvoker& invoker_;
-};
-
-
-

include/ipc/IpcMessage.h

@@ -39,27 +39,16 @@ public:
     }
 
     bool empty() const {
-        // Для входящих сообщений считаем "пустым" то, у которого
-        // больше не осталось непрочитанных данных во входном потоке.
-        //
-        // Для свежесозданного сообщения (ещё не инициализирован in_)
-        // поведение остаётся прежним: пусто == raw_.empty().
-        if (!in_initialized_) {
         return raw_.empty();
     }
 
-        // Если поток уже инициализирован, смотрим, остались ли данные.
-        // peek() вернёт EOF, когда всё прочитано.
-        return in_.peek() == EOF;
-    }
-
 private:
     std::string raw_;
     std::ostringstream out_;
-    mutable std::istringstream in_;
+    std::istringstream in_;
-    mutable bool in_initialized_{false};
+    bool in_initialized_{false};
 
-    void ensureInput() const {
+    void ensureInput() {
         if (!in_initialized_) {
             in_.str(raw_);
             in_initialized_ = true;

include/proxy/ProxyMarshaller.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <ipc/IpcChannel.h>
-#include <ipc/IpcCodec.h>
 #include <rpc/RpcValue.h>
 
 class ProxyMarshaller {
@@ -10,15 +9,22 @@ public:
 
     // Базовый type-erased вызов: принимает вектор RpcValue и возвращает RpcValue.
     RpcValue call(const std::string& method, const RpcArgs& args) {
-        // упаковать запрос в IpcMessage
+        IpcMessage msg;
-        IpcMessage msg = IpcCodec::encodeRequest(method, args);
+
+        // имя метода
+        msg.add(method);
+
+        // аргументы (PoC: только int)
+        for (const auto& a : args) {
+            msg.add(a.asInt());
+        }
 
         // отправить
         channel.send(msg);
 
-        // получить ответ и распаковать
+        // получить ответ
         IpcMessage resp = channel.receive();
-        return IpcCodec::decodeResponse(resp);
+        return RpcValue::fromInt(resp.get<int>());
     }
 
     // Удобный шаблонный хелпер для сгенерированных прокси.

src/server.cpp

@@ -2,8 +2,6 @@
 #include "MyService.skeleton.h"
 
 #include "ipc/IpcPipeChannel.h"
-#include "ipc/IpcDispatcher.h"
-#include "rpc/RpcInvoker.h"
 
 #include <sys/stat.h>
 
@@ -16,13 +14,17 @@ int main() {
     // Сервер читает из fifo_to_server и пишет в fifo_to_client.
     IpcPipeChannel ch("/tmp/fifo_to_server", "/tmp/fifo_to_client");
 
-    // RPC‑уровень: инвокер и скелет, который лишь регистрирует методы.
+    // RPC‑уровень: скелет поверх того же канала.
-    RpcInvoker invoker;
     MyService realObj;
-    MyServiceSkeleton skeleton(realObj, invoker);
+    MyServiceSkeleton skeleton(realObj);
 
-    // IPC‑диспетчер, который декодирует IpcMessage в RPC-вызовы и обратно.
+    while (true) {
-    IpcDispatcher dispatcher(ch, invoker);
+        IpcMessage req = ch.receive();
-    dispatcher.loop();
+        if (req.empty()) {
+            break;
+        }
+        IpcMessage resp = skeleton.dispatch(req);
+        ch.send(resp);
+    }
 }
 

tools/templates/skeleton.cpp.j2

@@ -1,7 +1,7 @@
 #include "{{ cls.name }}.skeleton.h"
 
-{{ cls.name }}Skeleton::{{ cls.name }}Skeleton({{ cls.name }}& obj, RpcInvoker& inv)
+{{ cls.name }}Skeleton::{{ cls.name }}Skeleton({{ cls.name }}& obj)
-    : invoker(inv) {
+{
 {% for m in cls.methods %}
     invoker.registerMethod(&obj,
         "{{ cls.name }}.{{ m.name }}",
@@ -9,8 +9,24 @@
 {% endfor %}
 }
 
-RpcValue {{ cls.name }}Skeleton::dispatch(const std::string& method,
+IpcMessage {{ cls.name }}Skeleton::dispatch(const IpcMessage& req) {
-                                          const RpcArgs& args) {
+    // Перепаковываем IpcMessage в RpcArgs и вызываем type-erased инвокер.
-    return invoker.dispatch(method, args);
+    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;
 }
 

tools/templates/skeleton.h.j2

@@ -2,14 +2,14 @@
 
 #include "{{ cls.name }}.h"
 #include "rpc/RpcInvoker.h"
+#include "ipc/IpcMessage.h"
 
 class {{ cls.name }}Skeleton {
 public:
-    explicit {{ cls.name }}Skeleton({{ cls.name }}& obj, RpcInvoker& invoker);
+    explicit {{ cls.name }}Skeleton({{ cls.name }}& obj);
 
-    // IPC-независимый диспетчер: принимает имя метода и RpcArgs.
+    IpcMessage dispatch(const IpcMessage& req);
-    RpcValue dispatch(const std::string& method, const RpcArgs& args);
 
 private:
-    RpcInvoker& invoker;
+    RpcInvoker invoker;
 };