protobuf_message_read_writer.hpp

Go to the documentation of this file.

#ifndef KAGOME_PROTOBUF_MESSAGE_READ_WRITER_HPP
#define KAGOME_PROTOBUF_MESSAGE_READ_WRITER_HPP

#include <functional>
#include <memory>

#include <libp2p/basic/message_read_writer_uvarint.hpp>
#include <libp2p/basic/protobuf_message_read_writer.hpp>
#include <outcome/outcome.hpp>

#include "network/adapters/protobuf.hpp"
#include "network/adapters/uvar.hpp"
#include "network/helpers/message_read_writer.hpp"
#include "scale/scale.hpp"

namespace kagome::network {
  class ProtobufMessageReadWriter
      : public std::enable_shared_from_this<ProtobufMessageReadWriter> {
    template <typename MsgType>
    using ReadCallback = std::function<void(outcome::result<MsgType>)>;

    std::shared_ptr<libp2p::basic::MessageReadWriter> read_writer_;

   public:
    explicit ProtobufMessageReadWriter(
        const std::shared_ptr<libp2p::basic::ReadWriter> &read_writer)
        : read_writer_(
            std::make_shared<libp2p::basic::MessageReadWriterUvarint>(
                read_writer)) {}

    template <typename MsgType>
    void read(ReadCallback<MsgType> &&cb) const {
      read_writer_->read(
          [self{shared_from_this()}, cb = std::move(cb)](auto &&read_res) {
            if (!read_res) {
              return cb(read_res.error());
            }

            using ProtobufRW =
                MessageReadWriter<ProtobufMessageAdapter<MsgType>, NoSink>;

            MsgType msg;
            if (read_res.value()) {
              if (auto msg_res = ProtobufRW::read(
                      msg, *read_res.value(), read_res.value()->begin());
                  !msg_res) {
                return cb(msg_res.error());
              }
            }
            return cb(std::move(msg));
          });
    }

    template <typename MsgType>
    void write(const MsgType &msg,
               libp2p::basic::Writer::WriteCallbackFunc &&cb) const {
      using ProtobufRW =
          MessageReadWriter<ProtobufMessageAdapter<MsgType>, NoSink>;

      // TODO(iceseer): PRE-523 cache this vector
      std::vector<uint8_t> out;
      auto it = ProtobufRW::write(msg, out);

      gsl::span<uint8_t> data(it.base(),
                              out.size() - std::distance(out.begin(), it));

      read_writer_->write(data,
                          [self{shared_from_this()},
                           out{std::move(out)},
                           cb = std::move(cb)](auto &&write_res) {
                            if (!write_res) {
                              return cb(write_res.error());
                            }
                            cb(outcome::success());
                          });
    }
  };

}  // namespace kagome::network

#endif  // KAGOME_PROTOBUF_MESSAGE_READ_WRITER_HPP