Merge pull request #4 from threeal/add-result

Add Result

Author: threeal

CMakeLists.txt

@@ -1,16 +1,20 @@
 cmake_minimum_required(VERSION 3.14)
 
 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake;${CMAKE_MODULE_PATH}")
+set(CMAKE_CXX_STANDARD 17)
 
 project(result)
 
+add_library(result INTERFACE)
+target_include_directories(result INTERFACE include)
+
 if(BUILD_TESTING)
   enable_testing()
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -coverage")
 
   find_package(Catch2 REQUIRED)
 
   add_executable(result_test test/result_test.cpp)
-  target_link_libraries(result_test PRIVATE Catch2::Catch2WithMain)
+  target_link_libraries(result_test PRIVATE result Catch2::Catch2WithMain)
   catch_discover_tests(result_test)
 endif()

include/result/internal/err_msg.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+namespace res::internal {
+
+using ErrMsg = std::string;
+using ErrMsgPtr = std::shared_ptr<ErrMsg>;
+
+ErrMsgPtr uninitialized_err_msg_ptr = std::make_shared<ErrMsg>("result is uninitialized");
+}

include/result/internal/ok.hpp

@@ -0,0 +1,7 @@
+#pragma once
+
+namespace res {
+
+namespace internal { struct Ok {}; }
+constexpr internal::Ok ok = {};
+}

include/result/result.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "internal/err_msg.hpp"
+#include "internal/ok.hpp"
+#include <exception>
+#include <memory>
+
+namespace res {
+
+class Result {
+ private:
+  internal::ErrMsgPtr err_msg_ptr;
+ public:
+  Result() : err_msg_ptr(internal::uninitialized_err_msg_ptr) {}
+  Result(const internal::Ok& ok) {}
+  Result(const internal::ErrMsgPtr& err_msg_ptr) : err_msg_ptr(err_msg_ptr) {}
+
+  template<typename E>
+  Result(const E& err_msg) : err_msg_ptr(std::make_shared<internal::ErrMsg>(err_msg)) {}
+
+  bool is_ok() const { return !err_msg_ptr; }
+  bool is_err() const { return (bool)err_msg_ptr; }
+
+  internal::ErrMsg unwrap_err() const {
+    if (!err_msg_ptr) throw std::runtime_error("is ok");
+    return *err_msg_ptr;
+  }  // LCOV_EXCL_LINE
+};
+}

test/result_test.cpp

@@ -1,5 +1,81 @@
+#include <result/result.hpp>
 #include <catch2/catch_test_macros.hpp>
 
-TEST_CASE("example test") {
-  REQUIRE(true);
+TEST_CASE("check ok result") {
+  const res::Result res = res::ok;
+  REQUIRE(res.is_ok());
+  REQUIRE_FALSE(res.is_err());
+}
+
+TEST_CASE("check error result") {
+  const res::Result res = "unknown error";
+  REQUIRE(res.is_err());
+  REQUIRE_FALSE(res.is_ok());
+}
+
+TEST_CASE("uninitialized result contains error") {
+  const res::Result res;
+  REQUIRE(res.is_err());
+}
+
+TEST_CASE("call `unwrap_err` on error result") {
+  const res::internal::ErrMsg err_msg = "unknown error";
+  const res::Result res = err_msg;
+  REQUIRE(res.is_err());
+  REQUIRE(res.unwrap_err() == err_msg);
+}
+
+TEST_CASE("call `unwrap_err` on ok result") {
+  const res::Result res = res::ok;
+  REQUIRE(res.is_ok());
+  REQUIRE_THROWS(res.unwrap_err());
+}
+
+TEST_CASE("check rewriting result") {
+  res::Result res = res::ok;
+  REQUIRE(res.is_ok());
+  res::internal::ErrMsg err_msg = "unknown error";
+  res = err_msg;
+  REQUIRE(res.is_err());
+  REQUIRE(res.unwrap_err() == err_msg);
+  res = err_msg = "other error";
+  REQUIRE(res.is_err());
+  REQUIRE(res.unwrap_err() == err_msg);
+  res = res::ok;
+  REQUIRE(res.is_ok());
+}
+
+namespace {
+res::Result foo(bool is_ok) {
+  if (is_ok) return res::ok;
+  return "unknown error";
+}
+}
+
+TEST_CASE("get result from function returning ok") {
+  const auto res = foo(true);
+  REQUIRE(res.is_ok());
+}
+
+TEST_CASE("get result from function returning error") {
+  const auto res = foo(false);
+  REQUIRE(res.is_err());
+}
+
+TEST_CASE("check if ok result is preserved outside the scope") {
+  res::Result res;
+  {
+    res = foo(true);
+    REQUIRE(res.is_ok());
+  }
+  REQUIRE(res.is_ok());
+}
+
+TEST_CASE("check if error result is preserved outside the scope") {
+  res::Result res;
+  {
+    res = foo(false);
+    REQUIRE(res.is_err());
+  }
+  REQUIRE(res.is_err());
 }