optional

Signed-off-by: turuslan <[email protected]>

Author: turuslan

example/snp_chat/main.cpp

@@ -107,7 +107,7 @@ struct ChatController : ConnectionsController {
     fmt::println("#{} > {}", i_msg, msg);
   }
 
-  Coro<void> broadcast(std::optional<size_t> i_read,
+  Coro<void> broadcast(qtils::Optional<size_t> i_read,
                        size_t i_msg,
                        std::string msg) {
     for (auto &[i_write, writer] : writers) {
@@ -152,7 +152,7 @@ struct ChatController : ConnectionsController {
 struct Input {
   Input(IoContextPtr io_context_ptr) : fd_{*io_context_ptr, STDIN_FILENO} {}
 
-  Coro<std::optional<std::string>> read() {
+  Coro<qtils::Optional<std::string>> read() {
     auto [ec, n] = co_await boost::asio::async_read_until(
         fd_, buf_, "\n", boost::asio::as_tuple(boost::asio::use_awaitable));
     if (ec) {
@@ -175,7 +175,7 @@ struct Input {
 CoroOutcome<void> co_main(IoContextPtr io_context_ptr, size_t arg_i) {
   fmt::println("#{} (self)", arg_i);
 
-  std::optional<Port> listen_port;
+  qtils::Optional<Port> listen_port;
   GenesisHash genesis;
   ConnectionsConfig config{genesis, keys.at(arg_i)};
   auto is_server = arg_i == 0;
@@ -189,7 +189,7 @@ CoroOutcome<void> co_main(IoContextPtr io_context_ptr, size_t arg_i) {
     Input input{io_context_ptr};
     while (true) {
       auto msg = co_await input.read();
-      if (not msg) {
+      if (not msg.has_value()) {
         break;
       }
       msg->resize(std::min(msg->size(), ChatController::kMaxMsg));
@@ -216,10 +216,9 @@ CoroOutcome<void> co_main(IoContextPtr io_context_ptr, size_t arg_i) {
         [chat](ConnectionInfo info, StreamPtr stream) -> CoroOutcome<void> {
           co_return co_await chat->add(info, stream);
         });
-    std::optional<CoroHandler<void>> work_guard;
-    co_await coroHandler<void>([&](CoroHandler<void> &&handler) {
-      work_guard.emplace(std::move(handler));
-    });
+    qtils::Optional<CoroHandler<void>> work_guard;
+    co_await coroHandler<void>(
+        [&](CoroHandler<void> &&handler) { work_guard = std::move(handler); });
   }
   co_return outcome::success();
 }

src/TODO_qtils/from_span.hpp

@@ -10,6 +10,7 @@
 #include <optional>
 #include <stdexcept>
 
+#include <TODO_qtils/optional.hpp>
 #include <qtils/bytes.hpp>
 
 namespace qtils {
@@ -22,7 +23,7 @@ namespace qtils {
   }
 
   template <typename T>
-  std::optional<T> fromSpan(BytesIn span) {
+  Optional<T> fromSpan(BytesIn span) {
     T out;
     if (not fromSpan(out, span)) {
       return std::nullopt;

src/TODO_qtils/optional.hpp

@@ -0,0 +1,79 @@
+/**
+ * Copyright Quadrivium LLC
+ * All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <optional>
+
+namespace qtils {
+  /**
+   * `std::optional` wrapper.
+   * Becomes `std::nullopt` when moved from.
+   * `std::nullopt` throws on access to value.
+   * Requires to write `.has_value()`.
+   * Can be move assigned for move only types.
+   */
+  template <typename T>
+  class Optional {
+   public:
+    Optional() : value_{std::nullopt} {}
+
+    Optional(const std::nullopt_t &) : value_{std::nullopt} {}
+
+    Optional(const T &value) : value_{value} {}
+    void operator=(const T &value) {
+      value_.emplace(value);
+    }
+
+    Optional(T &&value) : value_{std::move(value)} {}
+    void operator=(T &&value) {
+      value_.emplace(std::move(value));
+    }
+
+    Optional(const Optional<T> &other) : value_{other.value_} {}
+    void operator=(const Optional<T> &other) {
+      value_ = other.value_;
+    }
+
+    Optional(Optional<T> &&other)
+        : value_{std::exchange(other.value_, std::nullopt)} {}
+    void operator=(Optional<T> &&other) {
+      if (other.value_.has_value()) {
+        value_.emplace(std::exchange(other.value_, std::nullopt).value());
+      } else {
+        value_.reset();
+      }
+    }
+
+    bool has_value() const {
+      return value_.has_value();
+    }
+
+    T &operator*() {
+      return value_.value();
+    }
+    const T &operator*() const {
+      return value_.value();
+    }
+    T *operator->() {
+      return &value_.value();
+    }
+    const T *operator->() const {
+      return &value_.value();
+    }
+
+    Optional<T> take() {
+      return std::exchange(*this, Optional<T>{});
+    }
+
+    bool operator==(const T &value) const {
+      return value_ == value;
+    }
+
+   private:
+    std::optional<T> value_;
+  };
+}  // namespace qtils

src/crypto/ed25519.hpp

@@ -47,14 +47,12 @@ namespace jam::crypto::ed25519 {
   }
 
   inline Public get_public(const KeyPair &keypair) {
-    return qtils::fromSpan<Public>(
-               std::span{keypair}.subspan(ED25519_SECRET_KEY_LENGTH))
-        .value();
+    return *qtils::fromSpan<Public>(
+        std::span{keypair}.subspan(ED25519_SECRET_KEY_LENGTH));
   }
 
   inline Public get_secret(const KeyPair &keypair) {
-    return qtils::fromSpan<Secret>(
-               std::span{keypair}.first(ED25519_SECRET_KEY_LENGTH))
-        .value();
+    return *qtils::fromSpan<Secret>(
+        std::span{keypair}.first(ED25519_SECRET_KEY_LENGTH));
   }
 }  // namespace jam::crypto::ed25519

src/snp/connections/config.hpp

@@ -15,6 +15,6 @@ namespace jam::snp {
     // https://github.com/zdave-parity/jam-np/blob/5d374b53578cdd93646e3ee19e2b19ea132317b8/simple.md?plain=1#L30-L35
     GenesisHash genesis;
     crypto::ed25519::KeyPair keypair;
-    std::optional<Port> listen_port;
+    qtils::Optional<Port> listen_port;
   };
 }  // namespace jam::snp

src/snp/connections/connections.cpp

@@ -45,7 +45,7 @@ namespace jam::snp {
                                               certificate,
                                               std::nullopt,
                                               self));
-    if (self->config_.listen_port) {
+    if (self->config_.listen_port.has_value()) {
       BOOST_OUTCOME_CO_TRY(self->server_,
                            lsquic::Engine::make(self->io_context_ptr_,
                                                 self->connection_id_counter_,

src/snp/connections/connections.hpp

@@ -81,7 +81,7 @@ namespace jam::snp {
     Key key_;
     std::weak_ptr<ConnectionsController> controller_;
     std::shared_ptr<lsquic::Engine> client_;
-    std::optional<std::shared_ptr<lsquic::Engine>> server_;
+    qtils::Optional<std::shared_ptr<lsquic::Engine>> server_;
     std::unordered_map<Key,
                        std::variant<Connecting, Connected>,
                        qtils::BytesStdHash>