Source code
Revision control
Copy as Markdown
Other Tools
diff --git a/intl/icu_capi/cpp/include/diplomat_runtime.hpp b/intl/icu_capi/cpp/include/diplomat_runtime.hpp
--- a/intl/icu_capi/cpp/include/diplomat_runtime.hpp
+++ b/intl/icu_capi/cpp/include/diplomat_runtime.hpp
@@ -49,52 +49,60 @@ template<typename T> struct WriteableTra
template<> struct WriteableTrait<std::string> {
static inline capi::DiplomatWriteable Construct(std::string& t) {
return diplomat::WriteableFromString(t);
}
};
template<class T> struct Ok {
T inner;
- Ok(T&& i): inner(std::move(i)) {}
+ explicit Ok(T&& i): inner(std::move(i)) {}
// We don't want to expose an lvalue-capable constructor in general
// however there is no problem doing this for trivially copyable types
template<typename X = T, typename = typename std::enable_if<std::is_trivially_copyable<X>::value>::type>
- Ok(T i): inner(i) {}
+ explicit Ok(const T& i): inner(i) {}
Ok() = default;
Ok(Ok&&) noexcept = default;
Ok(const Ok &) = default;
Ok& operator=(const Ok&) = default;
Ok& operator=(Ok&&) noexcept = default;
};
template<class T> struct Err {
T inner;
- Err(T&& i): inner(std::move(i)) {}
+ explicit Err(T&& i): inner(std::move(i)) {}
// We don't want to expose an lvalue-capable constructor in general
// however there is no problem doing this for trivially copyable types
template<typename X = T, typename = typename std::enable_if<std::is_trivially_copyable<X>::value>::type>
- Err(T i): inner(i) {}
+ explicit Err(const T& i): inner(i) {}
Err() = default;
Err(Err&&) noexcept = default;
Err(const Err &) = default;
Err& operator=(const Err&) = default;
Err& operator=(Err&&) noexcept = default;
};
template<class T, class E>
class result {
private:
std::variant<Ok<T>, Err<E>> val;
public:
- result(Ok<T>&& v): val(std::move(v)) {}
- result(Err<E>&& v): val(std::move(v)) {}
+ explicit result(Ok<T>&& v): val(std::move(v)) {}
+ explicit result(Err<E>&& v): val(std::move(v)) {}
result() = default;
result(const result &) = default;
result& operator=(const result&) = default;
+ result& operator=(Ok<T>&& t) {
+ this->val = Ok<T>(std::move(t));
+ return *this;
+ }
+ result& operator=(Err<E>&& e) {
+ this->val = Err<E>(std::move(e));
+ return *this;
+ }
result& operator=(result&&) noexcept = default;
result(result &&) noexcept = default;
~result() = default;
bool is_ok() const {
return std::holds_alternative<Ok<T>>(this->val);
};
bool is_err() const {
return std::holds_alternative<Err<E>>(this->val);
@@ -142,17 +150,17 @@ template<class T> using span = std::span
// C++-17-compatible std::span
template<class T>
class span {
public:
constexpr span(T* data, size_t size)
: data_(data), size_(size) {}
template<size_t N>
- constexpr span(std::array<typename std::remove_const<T>::type, N>& arr)
+ explicit constexpr span(std::array<typename std::remove_const<T>::type, N>& arr)
: data_(const_cast<T*>(arr.data())), size_(N) {}
constexpr T* data() const noexcept {
return this->data_;
}
constexpr size_t size() const noexcept {
return this->size_;
}
private: