Merge pull request #1 from soramitsu/fix/kagome-compatibility

Fix kagome compatibility

Author: Harrm

README.md

@@ -9,8 +9,8 @@ It allows encoding and decoding following data types:
 * bool values
 * pairs of types represented by ```std::pair<T1, T2>```
 * compact integers represented by CompactInteger type
-* optional values represented by ```boost::optional<T>```
-    * as special case of optional values ```boost::optional<bool>``` is encoded using one byte following specification.
+* optional values represented by ```std::optional<T>```
+    * as special case of optional values ```std::optional<bool>``` is encoded using one byte following specification.
 * collections of items represented by ```std::vector<T>```
 * variants represented by ```boost::variant<T...>```
 
@@ -26,8 +26,8 @@ auto * raw_str = "zxczxczx";
 bool b = true;
 CompactInteger ci = 123456789;
 boost::variant<uint8_t, uint32_t, CompactInteger> vint = CompactInteger(12345);
-boost::optional<std::string> opt_str = "asdfghjkl";
-boost::optional<bool> opt_bool = false;
+std::optional<std::string> opt_str = "asdfghjkl";
+std::optional<bool> opt_bool = false;
 std::pair<uint8_t, uint32_t> pair{1u, 2u};
 std::vector<uint32_t> coll_ui32 = {1u, 2u, 3u, 4u};
 std::vector<std::string> coll_str = {"asd", "fgh", "jkl"};
@@ -58,8 +58,8 @@ std::string str;
 bool b = true;
 CompactInteger ci;
 boost::variant<uint8_t, uint32_t, CompactInteger> vint;
-boost::optional<std::string> opt_str;
-boost::optional<bool> opt_bool;
+std::optional<std::string> opt_str;
+std::optional<bool> opt_bool;
 std::pair<uint8_t, uint32_t> pair{};
 std::vector<uint32_t> coll_ui32;
 std::vector<std::string> coll_str;

…ude/scale/detail/fixed_witdh_integer.hpp …ude/scale/detail/fixed_width_integer.hppinclude/scale/detail/fixed_witdh_integer.hpp renamed to include/scale/detail/fixed_width_integer.hpp include/scale/detail/fixed_witdh_integer.hpp renamed to include/scale/detail/fixed_width_integer.hpp

@@ -21,7 +21,7 @@
 
 #define OUTCOME_USE_STD_IN_PLACE_TYPE 1
 
-namespace __outcome_detail {
+namespace scale::__outcome_detail {
 
 template <typename T> class Category : public std::error_category {
 public:
@@ -52,11 +52,11 @@ template <typename T> class Category : public std::error_category {
   Category() = default;
 }; /* end of class */
 
-} // namespace __outcome_detail
+} // namespace scale::__outcome_detail
 
 #define __OUTCOME_DEFINE_MAKE_ERROR_CODE(Enum)                                 \
   extern std::error_code make_error_code(Enum e) {                             \
-    return {static_cast<int>(e), __outcome_detail::Category<Enum>::get()};     \
+    return {static_cast<int>(e), scale::__outcome_detail::Category<Enum>::get()};     \
   }
 
 #define __OUTCOME_DECLARE_MAKE_ERROR_CODE(Enum)                                \
@@ -87,14 +87,14 @@ template <typename T> class Category : public std::error_category {
   __OUTCOME_DEFINE_MAKE_ERROR_CODE(Enum)                                       \
   };                                                                           \
   template <>                                                                  \
-  std::string __outcome_detail::Category<ns::Enum>::toString(ns::Enum Name)
+  std::string scale::__outcome_detail::Category<ns::Enum>::toString(ns::Enum Name)
 
 /// MUST BE EXECUTED AT FILE LEVEL(global namespace) IN CPP
 // Enum - enum name. Example: EncodeError
 // Name - variable name. Example: e
 #define OUTCOME_CPP_DEFINE_CATEGORY_2(Enum, Name)                              \
   __OUTCOME_DEFINE_MAKE_ERROR_CODE(Enum)                                       \
-  template <> std::string __outcome_detail::Category<Enum>::toString(Enum Name)
+  template <> std::string scale::__outcome_detail::Category<Enum>::toString(Enum Name)
 
 // kind of "macro overloading"
 #define __GET_MACRO_3(_1, _2, _3, NAME, ...) NAME

include/scale/outcome/outcome-register.hpp

@@ -15,15 +15,15 @@
 
 #include "outcome-register.hpp"
 
-namespace outcome {
+namespace scale::outcome {
 
 using namespace BOOST_OUTCOME_V2_NAMESPACE;
 
 template <class R, class S = std::error_code,
           class NoValuePolicy = policy::default_policy<R, S, void>>
 using result = basic_result<R, S, NoValuePolicy>;
 
-} // namespace outcome
+} // namespace scale::outcome
 
 #define OUTCOME_TRY(...) BOOST_OUTCOME_TRY(__VA_ARGS__)
 

include/scale/outcome/outcome.hpp

@@ -16,7 +16,7 @@ namespace scale {
    * @param t error value
    */
   template <typename T, typename = std::enable_if_t<std::is_enum_v<T>>>
-  [[noreturn]] void raise (T t) {
+  [[noreturn]] void raise(T t) {
     std::error_code ec = make_error_code(t);
     boost::throw_exception(std::system_error(ec));
   }