Standalone Maybe: refactor Variant, Optional, Maybe and more

cmake/oneflow.cmake

@@ -38,9 +38,14 @@ foreach(oneflow_hdr_to_be_expanded ${oneflow_all_hdr_to_be_expanded})
   set_source_files_properties(${oneflow_all_hdr_expanded} PROPERTIES GENERATED TRUE)
 endforeach()
 
-file(GLOB_RECURSE oneflow_all_src "${PROJECT_SOURCE_DIR}/oneflow/core/*.*"
-     "${PROJECT_SOURCE_DIR}/oneflow/user/*.*" "${PROJECT_SOURCE_DIR}/oneflow/api/*.*"
-     "${PROJECT_SOURCE_DIR}/oneflow/extension/python/*.*")
+file(
+  GLOB_RECURSE
+  oneflow_all_src
+  "${PROJECT_SOURCE_DIR}/oneflow/core/*.*"
+  "${PROJECT_SOURCE_DIR}/oneflow/user/*.*"
+  "${PROJECT_SOURCE_DIR}/oneflow/api/*.*"
+  "${PROJECT_SOURCE_DIR}/oneflow/maybe/*.*"
+  "${PROJECT_SOURCE_DIR}/oneflow/extension/python/*.*")
 if(WITH_XLA OR WITH_TENSORRT OR WITH_OPENVINO)
   file(GLOB_RECURSE oneflow_xrt_src "${PROJECT_SOURCE_DIR}/oneflow/xrt/*.*")
   if(NOT WITH_XLA)

cmake/third_party.cmake

@@ -26,6 +26,7 @@ if(RPC_BACKEND MATCHES "GRPC")
 endif()
 include(flatbuffers)
 include(lz4)
+include(string_view)
 
 if(WITH_XLA)
   include(tensorflow)
@@ -145,7 +146,8 @@ set(oneflow_third_party_libs
     ${CMAKE_THREAD_LIBS_INIT}
     ${FLATBUFFERS_STATIC_LIBRARIES}
     ${LZ4_STATIC_LIBRARIES}
-    nlohmann_json::nlohmann_json)
+    nlohmann_json::nlohmann_json
+    string-view-lite)
 if(WITH_ONEDNN)
   set(oneflow_third_party_libs ${oneflow_third_party_libs} ${ONEDNN_STATIC_LIBRARIES})
 endif()

cmake/third_party/string_view.cmake

@@ -0,0 +1,9 @@
+include(FetchContent)
+
+set_mirror_url_with_hash(
+  string_view_URL "https://github.com/martinmoene/string-view-lite/archive/refs/tags/v1.6.0.tar.gz"
+  2bdbfa2def2d460e3f78ee9846ece943)
+
+FetchContent_Declare(string_view URL ${string_view_URL} URL_HASH MD5=${string_view_URL_HASH})
+
+FetchContent_MakeAvailable(string_view)

oneflow/maybe/config.h

@@ -37,16 +37,30 @@ limitations under the License.
 #if !__is_identifier(__is_aggregate)
 #define OF_MAYBE_HAS_IS_AGGREGATE
 #endif
-#elif __has_builtin(__is_aggregate)
+#else
+#if __has_builtin(__is_aggregate)
 #define OF_MAYBE_HAS_IS_AGGREGATE
 #endif
+#endif
 
 #ifdef OF_MAYBE_HAS_IS_AGGREGATE
-#define OF_MAYBE_IS_AGGREGATE(...) __is_aggregate(__VA_ARGS__)
+#define OF_MAYBE_IS_AGGREGATE(...) (__is_aggregate(__VA_ARGS__))
 #else
 // decay to POD checking if no such builtin (because implementing __is_aggregate need reflection)
 #define OF_MAYBE_IS_AGGREGATE(...) \
-  std::is_standard_layout<__VA_ARGS__>::value&& std::is_trivial<__VA_ARGS__>::value
+  (std::is_standard_layout<__VA_ARGS__>::value && std::is_trivial<__VA_ARGS__>::value)
+#endif
+
+// `__builtin_expect` exists at least since GCC 4 / Clang 3
+#define OF_MAYBE_EXPECT_FALSE(x) (__builtin_expect((x), 0))
+
+#if __has_cpp_attribute(nodiscard)
+#define OF_MAYBE_NODISCARD_FUNC [[nodiscard]]
+#define OF_MAYBE_NODISCARD_TYPE [[nodiscard]]
+#elif __has_attribute(warn_unused_result)
+#define OF_MAYBE_NODISCARD_FUNC \
+  __attribute__((warn_unused_result))  // or [[gnu::warn_unused_result]]
+#define OF_MAYBE_NODISCARD_TYPE
 #endif
 
 #endif  // ONEFLOW_MAYBE_CONFIG_H_

oneflow/maybe/error.h

@@ -0,0 +1,283 @@
+/*
+Copyright 2020 The OneFlow Authors. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#ifndef ONEFLOW_MAYBE_ERROR_H_
+#define ONEFLOW_MAYBE_ERROR_H_
+
+#include <cstddef>
+#include <cstdlib>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <vector>
+#include <iostream>
+
+#include "utility.h"
+#include "type_traits.h"
+#include "string_view.h"
+
+namespace oneflow {
+
+namespace maybe {
+
+namespace details {
+
+template<typename D>
+struct ErrorStackFromContainerBase {
+ private:
+  using Derived = D;
+
+  auto& Stack() { return static_cast<Derived*>(this)->GetStack(); }
+
+  const auto& Stack() const { return static_cast<const Derived*>(this)->GetStack(); }
+
+ public:
+  std::size_t StackSize() const { return Stack().size(); }
+
+  template<typename... Args>
+  void PushStack(Args&&... args) {
+    auto& s = Stack();
+    s.emplace(s.end(), std::forward<Args>(args)...);
+  }
+
+  template<typename T = Derived>
+  const typename T::StackType::value_type& StackElem(std::size_t index) const {
+    return Stack()[index];
+  }
+
+  auto StackBegin() const { return Stack().begin(); }
+  auto StackEnd() const { return Stack().end(); }
+};
+
+}  // namespace details
+
+template<typename T>
+struct StackedErrorTraits {
+  StackedErrorTraits() = delete;
+
+  using ErrorType = typename T::ErrorType;
+  using StackEntryType = typename T::StackEntryType;
+
+  template<
+      typename U,
+      std::enable_if_t<
+          std::is_same<T, RemoveCVRef<U>>::value
+              && std::is_same<ErrorType, RemoveCVRef<decltype(std::declval<U>().Error())>>::value,
+          int> = 0>
+  static decltype(auto) Error(U&& se) {
+    return se.Error();
+  }
+
+  static std::size_t StackSize(const T& se) { return se.StackSize(); }
+
+  static ConstRefExceptVoid<StackEntryType> StackElem(const T& se, std::size_t index) {
+    return se.StackElem(index);
+  }
+
+  template<typename U, typename... Args,
+           std::enable_if_t<std::is_same<T, RemoveCVRef<U>>::value, int> = 0>
+  static void PushStack(U&& se, Args&&... args) {
+    se.PushStack(std::forward<Args>(args)...);
+  }
+
+  template<typename U, std::enable_if_t<std::is_same<T, RemoveCVRef<U>>::value, int> = 0>
+  static std::string Dump(U&& se) {
+    return se.Dump();
+  }
+
+  template<typename U, std::enable_if_t<std::is_same<T, RemoveCVRef<U>>::value, int> = 0>
+  [[noreturn]] static void Abort(U&& se) {
+    se.Abort();
+  }
+};
+
+template<typename T>
+struct StackedErrorTraits<std::unique_ptr<T>> {
+  StackedErrorTraits() = delete;
+
+  using PointedTraits = StackedErrorTraits<T>;
+
+  using ValueType = std::unique_ptr<T>;
+
+  using ErrorType = typename PointedTraits::ErrorType;
+  using StackEntryType = typename PointedTraits::StackEntryType;
+
+  template<typename U, std::enable_if_t<std::is_same<ValueType, RemoveCVRef<U>>::value, int> = 0>
+  static decltype(auto) Error(U&& se) {
+    return PointedTraits::Error(*se);
+  }
+
+  static std::size_t StackSize(const ValueType& se) { return PointedTraits::StackSize(*se); }
+
+  static ConstRefExceptVoid<StackEntryType> StackElem(const T& se, std::size_t index) {
+    return PointedTraits::StackElem(*se, index);
+  }
+
+  template<typename U, typename... Args,
+           std::enable_if_t<std::is_same<ValueType, RemoveCVRef<U>>::value, int> = 0>
+  static void PushStack(U&& se, Args&&... args) {
+    PointedTraits::PushStack(*se, std::forward<Args>(args)...);
+  }
+
+  template<typename U, std::enable_if_t<std::is_same<ValueType, RemoveCVRef<U>>::value, int> = 0>
+  static std::string Dump(U&& se) {
+    return PointedTraits::Dump(*se);
+  }
+
+  template<typename U, std::enable_if_t<std::is_same<ValueType, RemoveCVRef<U>>::value, int> = 0>
+  [[noreturn]] static void Abort(U&& se) {
+    PointedTraits::Abort(*se);
+  }
+};
+
+// simple implementation for some customization points
+namespace simple {
+
+template<typename T>
+struct MessageFormatTrait;
+
+template<>
+struct MessageFormatTrait<std::string> {
+  template<typename Code, typename... Args>
+  static std::string Format(Code&& code, Args&&... args) {
+    if (sizeof...(args) > 0) {
+      std::stringstream res;
+
+      res << code << ": ";
+      [[maybe_unused]] int dummy[] = {(res << args, 0)...};
+
+      return res.str();
+    } else {
+      return code;
+    }
+  }
+};
+
+template<>
+struct MessageFormatTrait<StringView> {
+  template<typename Code>
+  static StringView Format(Code&& code) {
+    return code;
+  }
+};
+
+template<typename Message, typename MessageFormatTraits = MessageFormatTrait<Message>>
+struct ErrorStackEntry {
+  StringView filename;
+  std::size_t lineno;
+  StringView function;
+  Message message;
+
+  template<typename... Args>
+  ErrorStackEntry(StringView filename, std::size_t lineno, StringView function, Args&&... args)
+      : filename(filename),
+        lineno(lineno),
+        function(function),
+        message(MessageFormatTraits::Format(std::forward<Args>(args)...)) {}
+};
+
+template<typename E, typename M = std::string>
+struct StackedError : details::ErrorStackFromContainerBase<StackedError<E, M>> {
+ public:
+  using ErrorType = E;
+  using StackMessage = M;
+  using StackEntryType = ErrorStackEntry<StackMessage>;
+  using StackType = std::vector<StackEntryType>;
+  using BaseType = details::ErrorStackFromContainerBase<StackedError<E, M>>;
+
+  static_assert(!std::is_reference<E>::value, "the underlying value type cannot be reference");
+
+  StackedError(ErrorType error)  // NOLINT(google-explicit-constructor)
+      : error_(std::move(error)) {}
+
+  ErrorType& Error() { return error_; }
+  const ErrorType& Error() const { return error_; }
+
+  std::string Dump() {
+    std::stringstream res;
+    res << "error occurred: " << error_ << std::endl;
+    for (const auto& elem : stack_) {
+      res << "from " << elem.function << " in " << elem.filename << ":" << elem.lineno << ": "
+          << elem.message << std::endl;
+    }
+
+    return res.str();
+  }
+
+  [[noreturn]] void Abort() {
+    std::cerr << "error occurred: " << error_ << std::endl;
+    for (const auto& elem : stack_) {
+      std::cerr << "from " << elem.function << " in " << elem.filename << ":" << elem.lineno << ": "
+                << elem.message << std::endl;
+    }
+    std::abort();
+  }
+
+ private:
+  ErrorType error_;
+  StackType stack_;
+
+  StackType& GetStack() { return stack_; }
+
+  const StackType& GetStack() const { return stack_; }
+
+  friend BaseType;
+};
+
+template<typename E>
+struct NoStackError {
+  using ErrorType = E;
+  using StackEntryType = void;
+
+  static_assert(!std::is_reference<E>::value, "the underlying value type cannot be reference");
+
+  NoStackError(ErrorType error)  // NOLINT(google-explicit-constructor)
+      : error_(std::move(error)) {}
+
+  ErrorType& Error() { return error_; }
+  const ErrorType& Error() const { return error_; }
+
+  std::size_t StackSize() const { return 0; }
+
+  void StackElem(std::size_t) const {}
+
+  template<typename... Args>
+  void PushStack(Args&&... args) {}
+
+  std::string Dump() {
+    std::stringstream res;
+    res << error_ << std::endl;
+
+    return res.str();
+  }
+
+  [[noreturn]] void Abort() {
+    std::cerr << error_ << std::endl;
+    std::abort();
+  }
+
+ private:
+  ErrorType error_;
+};
+
+}  // namespace simple
+
+}  // namespace maybe
+
+}  // namespace oneflow
+
+#endif  // ONEFLOW_MAYBE_ERROR_H_