Bka tl expected

Introduce ds::Expected as a more sage alternative to std::optional that carries error in failed state.

src/ds/expected-test.cpp

+/*
+    Copyright (c) 2020 digitalSTROM.org, Zurich, Switzerland
+
+    This file is part of digitalSTROM Server.
+
+    digitalSTROM Server is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    digitalSTROM Server is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with digitalSTROM Server. If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "expected.h"
+
+#include <ds/catch/catch.h>
+
+namespace {
+
+static const char* TAGS = "[dsExpected][ds]";
+
+TEST_CASE("dsExpected", TAGS) {
+  GIVEN("value initialized") {
+    auto x = ds::Expected<int>(3);
+
+    THEN("value()") { CHECK(x.value() == 3); }
+    THEN("operator bool") { CHECK(x); }
+    THEN("operator ==, !=") {
+      CHECK(x == 3);
+      CHECK(x != 4);
+    }
+    THEN("value_or()") { CHECK(x.value_or(-1) == 3); }
+    THEN("has_value()") { CHECK(x.has_value()); }
+    THEN("map") {
+      CHECK(x.map([](auto&& y) { return ds::str(y); }) == "3");
+    }
+    THEN("and_then with value") {
+      CHECK(x.and_then([](auto&& y) -> ds::Expected<std::string> { return ds::str(y); }) == "3");
+    }
+    THEN("and_then with error") {
+      CHECK(!x.and_then([](auto &&) -> ds::Expected<std::string> { return DS_UNEXPECTED("test error"); }));
+    }
+  }
+  GIVEN("error initialized") {
+    auto x = ds::Expected<int>{DS_UNEXPECTED("test error")};
+
+    THEN("value()") { CHECK_THROWS_FIND(x.value(), "test error"); }
+    THEN("operator bool") { CHECK(!bool(x)); }
+    THEN("operator ==, !=") { CHECK(x != 3); }
+    THEN("value_or()") { CHECK(x.value_or(-1) == -1); }
+    THEN("has_value()") { CHECK(!x.has_value()); }
+    THEN("map") {
+      CHECK(!x.map([](auto&& y) -> std::string {
+        CHECK(false);
+        return {};
+      }));
+    }
+    THEN("and_then") {
+      CHECK(!x.and_then([](auto&& y) -> ds::Expected<std::string> {
+        CHECK(false);
+        return {};
+      }));
+    }
+  }
+}
+} // namespace

src/ds/expected.cpp

+#include "expected.h"

src/ds/expected.h

+/*
+    Copyright (c) 2020 digitalSTROM.org, Zurich, Switzerland
+
+    This file is part of digitalSTROM Server.
+
+    digitalSTROM Server is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    digitalSTROM Server is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with digitalSTROM Server. If not, see <http://www.gnu.org/licenses/>.
+*/
+#pragma once
+
+#include <tl/expected.hpp>
+
+#include "exception.h"
+#include "log.h"
+
+namespace ds {
+
+/// tl::expected (future std::expected) specialized
+/// with ds::Exception as error to support ds code style.
+///
+/// Contrary to tl(std)::expected
+/// * `operator *()` - not provided because it is unsafe
+/// * `value()` throws `ds::Exception` and not `bad_expected_access<ds::Exception>`
+/// * `error()` - not provided because it is unsafe. TODO(someday): Reevaluate when needed?
+///
+/// See also
+/// * https://github.com/TartanLlama/expected
+/// * http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0323r3.pdf
+template <class T>
+struct Expected : tl::expected<T, ds::Exception> {
+  using Super = tl::expected<T, ds::Exception>;
+  using typename Super::error_type;
+  using typename Super::unexpected_type;
+  using typename Super::value_type;
+
+  using tl::expected<T, ds::Exception>::expected;
+  using Super::operator=;
+  using Super::emplace;
+  using Super::swap;
+
+  // Returns the contained value or throws ds::Exception
+  template <class U = T, tl::detail::enable_if_t<!std::is_void<U>::value>* = nullptr>
+  TL_EXPECTED_11_CONSTEXPR const U& value() const& {
+    if (!has_value())
+      throw Super::err().value();
+    return Super::value();
+  }
+  template <class U = T, tl::detail::enable_if_t<!std::is_void<U>::value>* = nullptr>
+  TL_EXPECTED_11_CONSTEXPR U& value() & {
+    if (!has_value())
+      throw Super::error();
+    return Super::value();
+  }
+  template <class U = T, tl::detail::enable_if_t<!std::is_void<U>::value>* = nullptr>
+  TL_EXPECTED_11_CONSTEXPR const U&& value() const&& {
+    if (!has_value())
+      throw Super::error();
+    return Super::value();
+  }
+  template <class U = T, tl::detail::enable_if_t<!std::is_void<U>::value>* = nullptr>
+  TL_EXPECTED_11_CONSTEXPR U&& value() && {
+    if (!has_value())
+      throw Super::error();
+    return Super::value();
+  }
+
+  using Super::operator bool;
+  using Super::has_value;
+  using Super::value_or;
+
+  // Carries out some operation on the stored object if there is one.
+  using Super::map;
+
+  // Carries out some operation on the unexpected object if there is one.
+  using Super::map_error;
+
+  // Like map, but for operations which return a tl::expected
+  using Super::and_then;
+
+  // Calls some function if there is no value stored.
+  using Super::or_else;
+
+  // not safe
+  T* operator->() const = delete;
+  T* operator->() = delete;
+
+  // not safe
+  const T& operator*() const& = delete;
+  T& operator*() & = delete;
+  const T&& operator*() const&& = delete;
+  T&& operator*() && = delete;
+
+  // not safe
+  const error_type& error() const& = delete;
+  error_type& error() & = delete;
+  const error_type&& error() const&& = delete;
+  error_type&& error() && = delete;
+};
+
+#define DS_UNEXPECTED(...) \
+  tl::make_unexpected(ds::Exception(::ds::strArgs("" DS_MACRO_FOR_EACH(DS_ARG, ##__VA_ARGS__), DS_CONTEXT_ARGS)))
+
+} // namespace ds
+
+namespace tl::detail {
+// Trait for checking if a type is a tl::expected
+// Required by `and_then` methods.
+// Could be avoided by reimplementing `and_then`
+template <class T>
+struct is_expected_impl<ds::Expected<T>> : std::true_type {};
+
+} // namespace tl::detail

src/ds/meson.build

@@ -8,6 +8,7 @@ dsLibrary = library('ds', [
     'elapsed.cpp',
     'enum.cpp',
     'exception.cpp',
+    'expected.cpp',
     'http.cpp',
     'json.cpp',
     'latency-statistics.cpp',
@@ -74,6 +75,7 @@ dsTest = executable('ds-test', [
     'date-time-test.cpp',
     'enum-test.cpp',
     'exception-test.cpp',
+    'expected-test.cpp',
     'http-test.cpp',
     'json-test.cpp',
     'latency-statistics-test.cpp',