2013-08-28 02:10:28 +04:00
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
|
2014-08-14 02:39:40 +04:00
|
|
|
/* A class for optional values and in-place lazy construction. */
|
2013-08-28 02:10:28 +04:00
|
|
|
|
|
|
|
#ifndef mozilla_Maybe_h
|
|
|
|
#define mozilla_Maybe_h
|
|
|
|
|
|
|
|
#include "mozilla/Alignment.h"
|
|
|
|
#include "mozilla/Assertions.h"
|
2014-08-30 02:13:04 +04:00
|
|
|
#include "mozilla/Attributes.h"
|
2018-03-06 19:35:50 +03:00
|
|
|
#include "mozilla/MemoryChecking.h"
|
2014-08-14 02:39:40 +04:00
|
|
|
#include "mozilla/Move.h"
|
2017-02-14 22:23:18 +03:00
|
|
|
#include "mozilla/OperatorNewExtensions.h"
|
2018-03-06 19:35:50 +03:00
|
|
|
#include "mozilla/Poison.h"
|
2014-08-14 02:39:40 +04:00
|
|
|
#include "mozilla/TypeTraits.h"
|
2013-08-28 02:10:28 +04:00
|
|
|
|
2014-08-14 02:39:40 +04:00
|
|
|
#include <new> // for placement new
|
2017-01-18 21:53:35 +03:00
|
|
|
#include <ostream>
|
2016-08-24 21:12:48 +03:00
|
|
|
#include <type_traits>
|
2013-08-28 02:10:28 +04:00
|
|
|
|
2019-01-19 02:21:46 +03:00
|
|
|
class nsCycleCollectionTraversalCallback;
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
inline void CycleCollectionNoteChild(
|
|
|
|
nsCycleCollectionTraversalCallback& aCallback, T* aChild, const char* aName,
|
|
|
|
uint32_t aFlags);
|
|
|
|
|
2013-08-28 02:10:28 +04:00
|
|
|
namespace mozilla {
|
|
|
|
|
2014-08-14 02:39:40 +04:00
|
|
|
struct Nothing {};
|
|
|
|
|
2018-03-06 19:35:50 +03:00
|
|
|
namespace detail {
|
|
|
|
|
2018-04-10 20:46:00 +03:00
|
|
|
// You would think that poisoning Maybe instances could just be a call
|
|
|
|
// to mozWritePoison. Unfortunately, using a simple call to
|
|
|
|
// mozWritePoison generates poor code on MSVC for small structures. The
|
|
|
|
// generated code contains (always not-taken) branches and does a bunch
|
|
|
|
// of setup for `rep stos{l,q}`, even though we know at compile time
|
|
|
|
// exactly how many words we're poisoning. Instead, we're going to
|
|
|
|
// force MSVC to generate the code we want via recursive templates.
|
|
|
|
|
|
|
|
// Write the given poisonValue into p at offset*sizeof(uintptr_t).
|
|
|
|
template <size_t offset>
|
|
|
|
inline void WritePoisonAtOffset(void* p, const uintptr_t poisonValue) {
|
|
|
|
memcpy(static_cast<char*>(p) + offset * sizeof(poisonValue), &poisonValue,
|
|
|
|
sizeof(poisonValue));
|
|
|
|
}
|
|
|
|
|
|
|
|
template <size_t Offset, size_t NOffsets>
|
|
|
|
struct InlinePoisoner {
|
|
|
|
static void poison(void* p, const uintptr_t poisonValue) {
|
|
|
|
WritePoisonAtOffset<Offset>(p, poisonValue);
|
|
|
|
InlinePoisoner<Offset + 1, NOffsets>::poison(p, poisonValue);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <size_t N>
|
|
|
|
struct InlinePoisoner<N, N> {
|
|
|
|
static void poison(void*, const uintptr_t) {
|
|
|
|
// All done!
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// We can't generate inline code for large structures, though, because we'll
|
|
|
|
// blow out recursive template instantiation limits, and the code would be
|
|
|
|
// bloated to boot. So provide a fallback to the out-of-line poisoner.
|
|
|
|
template <size_t ObjectSize>
|
|
|
|
struct OutOfLinePoisoner {
|
2019-11-06 17:10:15 +03:00
|
|
|
static MOZ_NEVER_INLINE void poison(void* p, const uintptr_t) {
|
2018-04-10 20:46:00 +03:00
|
|
|
mozWritePoison(p, ObjectSize);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
inline void PoisonObject(T* p) {
|
|
|
|
const uintptr_t POISON = mozPoisonValue();
|
|
|
|
Conditional<(sizeof(T) <= 8 * sizeof(POISON)),
|
|
|
|
InlinePoisoner<0, sizeof(T) / sizeof(POISON)>,
|
|
|
|
OutOfLinePoisoner<sizeof(T)>>::Type::poison(p, POISON);
|
|
|
|
}
|
|
|
|
|
2018-03-06 19:35:50 +03:00
|
|
|
template <typename T>
|
|
|
|
struct MaybePoisoner {
|
|
|
|
static const size_t N = sizeof(T);
|
|
|
|
|
|
|
|
static void poison(void* aPtr) {
|
|
|
|
#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
|
|
|
|
if (N >= sizeof(uintptr_t)) {
|
2018-04-10 20:46:00 +03:00
|
|
|
PoisonObject(static_cast<typename RemoveCV<T>::Type*>(aPtr));
|
2018-03-06 19:35:50 +03:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
MOZ_MAKE_MEM_UNDEFINED(aPtr, N);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace detail
|
|
|
|
|
2013-08-28 02:10:28 +04:00
|
|
|
/*
|
2014-08-14 02:39:40 +04:00
|
|
|
* Maybe is a container class which contains either zero or one elements. It
|
|
|
|
* serves two roles. It can represent values which are *semantically* optional,
|
|
|
|
* augmenting a type with an explicit 'Nothing' value. In this role, it provides
|
|
|
|
* methods that make it easy to work with values that may be missing, along with
|
|
|
|
* equality and comparison operators so that Maybe values can be stored in
|
|
|
|
* containers. Maybe values can be constructed conveniently in expressions using
|
|
|
|
* type inference, as follows:
|
|
|
|
*
|
|
|
|
* void doSomething(Maybe<Foo> aFoo) {
|
|
|
|
* if (aFoo) // Make sure that aFoo contains a value...
|
|
|
|
* aFoo->takeAction(); // and then use |aFoo->| to access it.
|
|
|
|
* } // |*aFoo| also works!
|
|
|
|
*
|
|
|
|
* doSomething(Nothing()); // Passes a Maybe<Foo> containing no value.
|
|
|
|
* doSomething(Some(Foo(100))); // Passes a Maybe<Foo> containing |Foo(100)|.
|
|
|
|
*
|
|
|
|
* You'll note that it's important to check whether a Maybe contains a value
|
|
|
|
* before using it, using conversion to bool, |isSome()|, or |isNothing()|. You
|
|
|
|
* can avoid these checks, and sometimes write more readable code, using
|
|
|
|
* |valueOr()|, |ptrOr()|, and |refOr()|, which allow you to retrieve the value
|
|
|
|
* in the Maybe and provide a default for the 'Nothing' case. You can also use
|
|
|
|
* |apply()| to call a function only if the Maybe holds a value, and |map()| to
|
|
|
|
* transform the value in the Maybe, returning another Maybe with a possibly
|
|
|
|
* different type.
|
|
|
|
*
|
|
|
|
* Maybe's other role is to support lazily constructing objects without using
|
|
|
|
* dynamic storage. A Maybe directly contains storage for a value, but it's
|
|
|
|
* empty by default. |emplace()|, as mentioned above, can be used to construct a
|
|
|
|
* value in Maybe's storage. The value a Maybe contains can be destroyed by
|
|
|
|
* calling |reset()|; this will happen automatically if a Maybe is destroyed
|
|
|
|
* while holding a value.
|
|
|
|
*
|
|
|
|
* It's a common idiom in C++ to use a pointer as a 'Maybe' type, with a null
|
|
|
|
* value meaning 'Nothing' and any other value meaning 'Some'. You can convert
|
|
|
|
* from such a pointer to a Maybe value using 'ToMaybe()'.
|
|
|
|
*
|
|
|
|
* Maybe is inspired by similar types in the standard library of many other
|
|
|
|
* languages (e.g. Haskell's Maybe and Rust's Option). In the C++ world it's
|
|
|
|
* very similar to std::optional, which was proposed for C++14 and originated in
|
|
|
|
* Boost. The most important differences between Maybe and std::optional are:
|
2013-08-28 02:10:28 +04:00
|
|
|
*
|
2014-08-14 02:39:40 +04:00
|
|
|
* - std::optional<T> may be compared with T. We deliberately forbid that.
|
|
|
|
* - std::optional allows in-place construction without a separate call to
|
|
|
|
* |emplace()| by using a dummy |in_place_t| value to tag the appropriate
|
|
|
|
* constructor.
|
|
|
|
* - std::optional has |valueOr()|, equivalent to Maybe's |valueOr()|, but
|
|
|
|
* lacks corresponding methods for |refOr()| and |ptrOr()|.
|
|
|
|
* - std::optional lacks |map()| and |apply()|, making it less suitable for
|
|
|
|
* functional-style code.
|
|
|
|
* - std::optional lacks many convenience functions that Maybe has. Most
|
|
|
|
* unfortunately, it lacks equivalents of the type-inferred constructor
|
|
|
|
* functions |Some()| and |Nothing()|.
|
2013-08-28 02:10:28 +04:00
|
|
|
*/
|
|
|
|
template <class T>
|
2017-04-13 21:35:01 +03:00
|
|
|
class MOZ_NON_PARAM MOZ_INHERIT_TYPE_ANNOTATIONS_FROM_TEMPLATE_ARGS Maybe {
|
2017-08-17 02:49:19 +03:00
|
|
|
MOZ_ALIGNAS_IN_STRUCT(T) unsigned char mStorage[sizeof(T)];
|
2017-01-31 02:56:04 +03:00
|
|
|
char mIsSome; // not bool -- guarantees minimal space consumption
|
2017-01-03 11:53:05 +03:00
|
|
|
|
2017-01-31 02:56:04 +03:00
|
|
|
// GCC fails due to -Werror=strict-aliasing if |mStorage| is directly cast to
|
|
|
|
// T*. Indirecting through these functions addresses the problem.
|
|
|
|
void* data() { return mStorage; }
|
|
|
|
const void* data() const { return mStorage; }
|
2014-06-13 10:34:08 +04:00
|
|
|
|
2018-03-06 19:35:50 +03:00
|
|
|
void poisonData() { detail::MaybePoisoner<T>::poison(data()); }
|
|
|
|
|
2014-06-13 10:34:08 +04:00
|
|
|
public:
|
2017-01-31 02:56:04 +03:00
|
|
|
using ValueType = T;
|
2014-08-14 02:39:40 +04:00
|
|
|
|
2018-09-25 01:47:12 +03:00
|
|
|
MOZ_ALLOW_TEMPORARY Maybe() : mIsSome(false) {}
|
2014-08-14 02:39:40 +04:00
|
|
|
~Maybe() { reset(); }
|
2014-06-13 10:34:08 +04:00
|
|
|
|
2018-09-25 01:47:12 +03:00
|
|
|
MOZ_ALLOW_TEMPORARY MOZ_IMPLICIT Maybe(Nothing) : mIsSome(false) {}
|
2014-06-13 10:34:08 +04:00
|
|
|
|
2014-08-14 02:39:40 +04:00
|
|
|
Maybe(const Maybe& aOther) : mIsSome(false) {
|
|
|
|
if (aOther.mIsSome) {
|
|
|
|
emplace(*aOther);
|
|
|
|
}
|
2014-06-13 10:34:08 +04:00
|
|
|
}
|
|
|
|
|
2016-08-24 21:12:48 +03:00
|
|
|
/**
|
2016-12-23 03:49:33 +03:00
|
|
|
* Maybe<T> can be copy-constructed from a Maybe<U> if U is convertible to T.
|
2016-08-24 21:12:48 +03:00
|
|
|
*/
|
2016-12-23 03:49:33 +03:00
|
|
|
template <typename U, typename = typename std::enable_if<
|
|
|
|
std::is_convertible<U, T>::value>::type>
|
2016-08-24 21:12:48 +03:00
|
|
|
MOZ_IMPLICIT Maybe(const Maybe<U>& aOther) : mIsSome(false) {
|
|
|
|
if (aOther.isSome()) {
|
|
|
|
emplace(*aOther);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-14 02:39:40 +04:00
|
|
|
Maybe(Maybe&& aOther) : mIsSome(false) {
|
|
|
|
if (aOther.mIsSome) {
|
2018-05-30 22:15:35 +03:00
|
|
|
emplace(std::move(*aOther));
|
2014-08-14 02:39:40 +04:00
|
|
|
aOther.reset();
|
|
|
|
}
|
2014-06-13 10:34:08 +04:00
|
|
|
}
|
|
|
|
|
2016-08-24 21:12:48 +03:00
|
|
|
/**
|
2016-12-23 03:49:33 +03:00
|
|
|
* Maybe<T> can be move-constructed from a Maybe<U> if U is convertible to T.
|
2016-08-24 21:12:48 +03:00
|
|
|
*/
|
2016-12-23 03:49:33 +03:00
|
|
|
template <typename U, typename = typename std::enable_if<
|
|
|
|
std::is_convertible<U, T>::value>::type>
|
2016-08-24 21:12:48 +03:00
|
|
|
MOZ_IMPLICIT Maybe(Maybe<U>&& aOther) : mIsSome(false) {
|
|
|
|
if (aOther.isSome()) {
|
2018-05-30 22:15:35 +03:00
|
|
|
emplace(std::move(*aOther));
|
2016-08-24 21:12:48 +03:00
|
|
|
aOther.reset();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-14 02:39:40 +04:00
|
|
|
Maybe& operator=(const Maybe& aOther) {
|
|
|
|
if (&aOther != this) {
|
|
|
|
if (aOther.mIsSome) {
|
|
|
|
if (mIsSome) {
|
|
|
|
ref() = aOther.ref();
|
|
|
|
} else {
|
|
|
|
emplace(*aOther);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
reset();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return *this;
|
2014-06-13 10:34:08 +04:00
|
|
|
}
|
|
|
|
|
2016-12-23 03:49:33 +03:00
|
|
|
template <typename U, typename = typename std::enable_if<
|
|
|
|
std::is_convertible<U, T>::value>::type>
|
|
|
|
Maybe& operator=(const Maybe<U>& aOther) {
|
|
|
|
if (aOther.isSome()) {
|
|
|
|
if (mIsSome) {
|
|
|
|
ref() = aOther.ref();
|
|
|
|
} else {
|
|
|
|
emplace(*aOther);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
reset();
|
|
|
|
}
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2014-08-14 02:39:40 +04:00
|
|
|
Maybe& operator=(Maybe&& aOther) {
|
|
|
|
MOZ_ASSERT(this != &aOther, "Self-moves are prohibited");
|
|
|
|
|
|
|
|
if (aOther.mIsSome) {
|
|
|
|
if (mIsSome) {
|
2018-05-30 22:15:35 +03:00
|
|
|
ref() = std::move(aOther.ref());
|
2014-08-14 02:39:40 +04:00
|
|
|
} else {
|
2018-05-30 22:15:35 +03:00
|
|
|
emplace(std::move(*aOther));
|
2014-08-14 02:39:40 +04:00
|
|
|
}
|
|
|
|
aOther.reset();
|
|
|
|
} else {
|
|
|
|
reset();
|
|
|
|
}
|
|
|
|
|
|
|
|
return *this;
|
2014-06-13 10:34:08 +04:00
|
|
|
}
|
|
|
|
|
2016-12-23 03:49:33 +03:00
|
|
|
template <typename U, typename = typename std::enable_if<
|
|
|
|
std::is_convertible<U, T>::value>::type>
|
|
|
|
Maybe& operator=(Maybe<U>&& aOther) {
|
|
|
|
if (aOther.isSome()) {
|
|
|
|
if (mIsSome) {
|
2018-05-30 22:15:35 +03:00
|
|
|
ref() = std::move(aOther.ref());
|
2016-12-23 03:49:33 +03:00
|
|
|
} else {
|
2018-05-30 22:15:35 +03:00
|
|
|
emplace(std::move(*aOther));
|
2016-12-23 03:49:33 +03:00
|
|
|
}
|
|
|
|
aOther.reset();
|
|
|
|
} else {
|
|
|
|
reset();
|
|
|
|
}
|
|
|
|
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2014-08-14 02:39:40 +04:00
|
|
|
/* Methods that check whether this Maybe contains a value */
|
2015-02-03 19:52:36 +03:00
|
|
|
explicit operator bool() const { return isSome(); }
|
2014-08-14 02:39:40 +04:00
|
|
|
bool isSome() const { return mIsSome; }
|
|
|
|
bool isNothing() const { return !mIsSome; }
|
|
|
|
|
|
|
|
/* Returns the contents of this Maybe<T> by value. Unsafe unless |isSome()|.
|
|
|
|
*/
|
2018-05-21 17:03:59 +03:00
|
|
|
T value() const;
|
2014-06-13 10:34:08 +04:00
|
|
|
|
2014-08-22 11:43:02 +04:00
|
|
|
/*
|
|
|
|
* Returns the contents of this Maybe<T> by value. If |isNothing()|, returns
|
|
|
|
* the default value provided.
|
|
|
|
*/
|
|
|
|
template <typename V>
|
|
|
|
T valueOr(V&& aDefault) const {
|
|
|
|
if (isSome()) {
|
|
|
|
return ref();
|
|
|
|
}
|
2018-06-01 19:30:30 +03:00
|
|
|
return std::forward<V>(aDefault);
|
2014-08-22 11:43:02 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns the contents of this Maybe<T> by value. If |isNothing()|, returns
|
|
|
|
* the value returned from the function or functor provided.
|
|
|
|
*/
|
|
|
|
template <typename F>
|
|
|
|
T valueOrFrom(F&& aFunc) const {
|
|
|
|
if (isSome()) {
|
|
|
|
return ref();
|
|
|
|
}
|
|
|
|
return aFunc();
|
|
|
|
}
|
|
|
|
|
2014-08-14 02:39:40 +04:00
|
|
|
/* Returns the contents of this Maybe<T> by pointer. Unsafe unless |isSome()|.
|
|
|
|
*/
|
2018-05-21 17:03:59 +03:00
|
|
|
T* ptr();
|
|
|
|
const T* ptr() const;
|
2014-06-13 10:34:08 +04:00
|
|
|
|
2014-08-22 11:43:02 +04:00
|
|
|
/*
|
|
|
|
* Returns the contents of this Maybe<T> by pointer. If |isNothing()|,
|
|
|
|
* returns the default value provided.
|
|
|
|
*/
|
|
|
|
T* ptrOr(T* aDefault) {
|
|
|
|
if (isSome()) {
|
|
|
|
return ptr();
|
|
|
|
}
|
|
|
|
return aDefault;
|
|
|
|
}
|
|
|
|
|
|
|
|
const T* ptrOr(const T* aDefault) const {
|
|
|
|
if (isSome()) {
|
|
|
|
return ptr();
|
|
|
|
}
|
|
|
|
return aDefault;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns the contents of this Maybe<T> by pointer. If |isNothing()|,
|
|
|
|
* returns the value returned from the function or functor provided.
|
|
|
|
*/
|
|
|
|
template <typename F>
|
|
|
|
T* ptrOrFrom(F&& aFunc) {
|
|
|
|
if (isSome()) {
|
|
|
|
return ptr();
|
|
|
|
}
|
|
|
|
return aFunc();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename F>
|
|
|
|
const T* ptrOrFrom(F&& aFunc) const {
|
|
|
|
if (isSome()) {
|
|
|
|
return ptr();
|
|
|
|
}
|
|
|
|
return aFunc();
|
|
|
|
}
|
|
|
|
|
2018-05-21 17:03:59 +03:00
|
|
|
T* operator->();
|
|
|
|
const T* operator->() const;
|
2014-06-13 10:34:08 +04:00
|
|
|
|
2014-08-14 02:39:40 +04:00
|
|
|
/* Returns the contents of this Maybe<T> by ref. Unsafe unless |isSome()|. */
|
2018-05-21 17:03:59 +03:00
|
|
|
T& ref();
|
|
|
|
const T& ref() const;
|
2014-06-13 10:34:08 +04:00
|
|
|
|
2014-08-22 11:43:02 +04:00
|
|
|
/*
|
|
|
|
* Returns the contents of this Maybe<T> by ref. If |isNothing()|, returns
|
|
|
|
* the default value provided.
|
|
|
|
*/
|
|
|
|
T& refOr(T& aDefault) {
|
|
|
|
if (isSome()) {
|
|
|
|
return ref();
|
|
|
|
}
|
|
|
|
return aDefault;
|
|
|
|
}
|
|
|
|
|
|
|
|
const T& refOr(const T& aDefault) const {
|
|
|
|
if (isSome()) {
|
|
|
|
return ref();
|
|
|
|
}
|
|
|
|
return aDefault;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns the contents of this Maybe<T> by ref. If |isNothing()|, returns the
|
|
|
|
* value returned from the function or functor provided.
|
|
|
|
*/
|
|
|
|
template <typename F>
|
|
|
|
T& refOrFrom(F&& aFunc) {
|
|
|
|
if (isSome()) {
|
|
|
|
return ref();
|
|
|
|
}
|
|
|
|
return aFunc();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename F>
|
|
|
|
const T& refOrFrom(F&& aFunc) const {
|
|
|
|
if (isSome()) {
|
|
|
|
return ref();
|
|
|
|
}
|
|
|
|
return aFunc();
|
|
|
|
}
|
|
|
|
|
2018-05-21 17:03:59 +03:00
|
|
|
T& operator*();
|
|
|
|
const T& operator*() const;
|
2014-06-13 10:34:08 +04:00
|
|
|
|
2014-08-22 11:43:02 +04:00
|
|
|
/* If |isSome()|, runs the provided function or functor on the contents of
|
|
|
|
* this Maybe. */
|
2016-06-22 23:34:07 +03:00
|
|
|
template <typename Func>
|
2018-10-25 20:20:02 +03:00
|
|
|
Maybe& apply(Func&& aFunc) {
|
2014-08-22 11:43:02 +04:00
|
|
|
if (isSome()) {
|
2018-10-25 20:20:02 +03:00
|
|
|
std::forward<Func>(aFunc)(ref());
|
2014-08-22 11:43:02 +04:00
|
|
|
}
|
2016-06-22 23:34:07 +03:00
|
|
|
return *this;
|
2014-08-22 11:43:02 +04:00
|
|
|
}
|
|
|
|
|
2016-06-22 23:34:07 +03:00
|
|
|
template <typename Func>
|
2018-10-25 20:20:02 +03:00
|
|
|
const Maybe& apply(Func&& aFunc) const {
|
2014-08-22 11:43:02 +04:00
|
|
|
if (isSome()) {
|
2018-10-25 20:20:02 +03:00
|
|
|
std::forward<Func>(aFunc)(ref());
|
2014-08-22 11:43:02 +04:00
|
|
|
}
|
2016-06-22 23:34:07 +03:00
|
|
|
return *this;
|
2014-08-22 11:43:02 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If |isSome()|, runs the provided function and returns the result wrapped
|
2018-10-25 20:20:02 +03:00
|
|
|
* in a Maybe. If |isNothing()|, returns an empty Maybe value with the same
|
|
|
|
* value type as what the provided function would have returned.
|
2014-08-22 11:43:02 +04:00
|
|
|
*/
|
2016-06-22 23:34:07 +03:00
|
|
|
template <typename Func>
|
2018-10-25 20:20:02 +03:00
|
|
|
auto map(Func&& aFunc) {
|
|
|
|
Maybe<decltype(std::forward<Func>(aFunc)(ref()))> val;
|
2014-08-22 11:43:02 +04:00
|
|
|
if (isSome()) {
|
2018-10-25 20:20:02 +03:00
|
|
|
val.emplace(std::forward<Func>(aFunc)(ref()));
|
2014-08-22 11:43:02 +04:00
|
|
|
}
|
2018-10-25 20:20:02 +03:00
|
|
|
return val;
|
2014-08-22 11:43:02 +04:00
|
|
|
}
|
|
|
|
|
2016-06-22 23:34:07 +03:00
|
|
|
template <typename Func>
|
2018-10-25 20:20:02 +03:00
|
|
|
auto map(Func&& aFunc) const {
|
|
|
|
Maybe<decltype(std::forward<Func>(aFunc)(ref()))> val;
|
2014-08-22 11:43:02 +04:00
|
|
|
if (isSome()) {
|
2018-10-25 20:20:02 +03:00
|
|
|
val.emplace(std::forward<Func>(aFunc)(ref()));
|
2014-08-22 11:43:02 +04:00
|
|
|
}
|
2018-10-25 20:20:02 +03:00
|
|
|
return val;
|
2014-08-22 11:43:02 +04:00
|
|
|
}
|
|
|
|
|
2014-08-14 02:39:40 +04:00
|
|
|
/* If |isSome()|, empties this Maybe and destroys its contents. */
|
|
|
|
void reset() {
|
|
|
|
if (isSome()) {
|
2016-08-03 07:19:08 +03:00
|
|
|
ref().T::~T();
|
2014-08-14 02:39:40 +04:00
|
|
|
mIsSome = false;
|
2018-03-06 19:35:50 +03:00
|
|
|
poisonData();
|
2014-08-14 02:39:40 +04:00
|
|
|
}
|
2014-06-13 10:34:08 +04:00
|
|
|
}
|
|
|
|
|
2014-08-14 02:39:40 +04:00
|
|
|
/*
|
|
|
|
* Constructs a T value in-place in this empty Maybe<T>'s storage. The
|
|
|
|
* arguments to |emplace()| are the parameters to T's constructor.
|
|
|
|
*/
|
2015-01-13 02:48:10 +03:00
|
|
|
template <typename... Args>
|
2018-05-21 17:03:59 +03:00
|
|
|
void emplace(Args&&... aArgs);
|
2017-01-18 21:53:35 +03:00
|
|
|
|
|
|
|
friend std::ostream& operator<<(std::ostream& aStream,
|
|
|
|
const Maybe<T>& aMaybe) {
|
|
|
|
if (aMaybe) {
|
|
|
|
aStream << aMaybe.ref();
|
|
|
|
} else {
|
|
|
|
aStream << "<Nothing>";
|
|
|
|
}
|
|
|
|
return aStream;
|
|
|
|
}
|
2013-08-28 02:10:28 +04:00
|
|
|
};
|
|
|
|
|
2018-05-21 17:03:59 +03:00
|
|
|
template <typename T>
|
|
|
|
T Maybe<T>::value() const {
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(mIsSome);
|
|
|
|
return ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
T* Maybe<T>::ptr() {
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(mIsSome);
|
|
|
|
return &ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
const T* Maybe<T>::ptr() const {
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(mIsSome);
|
|
|
|
return &ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
T* Maybe<T>::operator->() {
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(mIsSome);
|
|
|
|
return ptr();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
const T* Maybe<T>::operator->() const {
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(mIsSome);
|
|
|
|
return ptr();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
T& Maybe<T>::ref() {
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(mIsSome);
|
|
|
|
return *static_cast<T*>(data());
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
const T& Maybe<T>::ref() const {
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(mIsSome);
|
|
|
|
return *static_cast<const T*>(data());
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
T& Maybe<T>::operator*() {
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(mIsSome);
|
|
|
|
return ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
const T& Maybe<T>::operator*() const {
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(mIsSome);
|
|
|
|
return ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
template <typename... Args>
|
|
|
|
void Maybe<T>::emplace(Args&&... aArgs) {
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(!mIsSome);
|
2018-06-01 19:30:30 +03:00
|
|
|
::new (KnownNotNull, data()) T(std::forward<Args>(aArgs)...);
|
2018-05-21 17:03:59 +03:00
|
|
|
mIsSome = true;
|
|
|
|
}
|
|
|
|
|
2014-08-14 02:39:40 +04:00
|
|
|
/*
|
|
|
|
* Some() creates a Maybe<T> value containing the provided T value. If T has a
|
|
|
|
* move constructor, it's used to make this as efficient as possible.
|
|
|
|
*
|
|
|
|
* Some() selects the type of Maybe it returns by removing any const, volatile,
|
|
|
|
* or reference qualifiers from the type of the value you pass to it. This gives
|
|
|
|
* it more intuitive behavior when used in expressions, but it also means that
|
|
|
|
* if you need to construct a Maybe value that holds a const, volatile, or
|
|
|
|
* reference value, you need to use emplace() instead.
|
|
|
|
*/
|
2016-12-23 03:32:33 +03:00
|
|
|
template <typename T, typename U = typename std::remove_cv<
|
|
|
|
typename std::remove_reference<T>::type>::type>
|
2014-08-14 02:39:40 +04:00
|
|
|
Maybe<U> Some(T&& aValue) {
|
|
|
|
Maybe<U> value;
|
2018-06-01 19:30:30 +03:00
|
|
|
value.emplace(std::forward<T>(aValue));
|
2014-08-14 02:39:40 +04:00
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
2014-08-22 11:43:02 +04:00
|
|
|
template <typename T>
|
|
|
|
Maybe<typename RemoveCV<typename RemoveReference<T>::Type>::Type> ToMaybe(
|
|
|
|
T* aPtr) {
|
|
|
|
if (aPtr) {
|
|
|
|
return Some(*aPtr);
|
|
|
|
}
|
|
|
|
return Nothing();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Two Maybe<T> values are equal if
|
|
|
|
* - both are Nothing, or
|
|
|
|
* - both are Some, and the values they contain are equal.
|
|
|
|
*/
|
|
|
|
template <typename T>
|
|
|
|
bool operator==(const Maybe<T>& aLHS, const Maybe<T>& aRHS) {
|
|
|
|
if (aLHS.isNothing() != aRHS.isNothing()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return aLHS.isNothing() || *aLHS == *aRHS;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
bool operator!=(const Maybe<T>& aLHS, const Maybe<T>& aRHS) {
|
|
|
|
return !(aLHS == aRHS);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We support comparison to Nothing to allow reasonable expressions like:
|
|
|
|
* if (maybeValue == Nothing()) { ... }
|
|
|
|
*/
|
|
|
|
template <typename T>
|
|
|
|
bool operator==(const Maybe<T>& aLHS, const Nothing& aRHS) {
|
|
|
|
return aLHS.isNothing();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
bool operator!=(const Maybe<T>& aLHS, const Nothing& aRHS) {
|
|
|
|
return !(aLHS == aRHS);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
bool operator==(const Nothing& aLHS, const Maybe<T>& aRHS) {
|
|
|
|
return aRHS.isNothing();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
bool operator!=(const Nothing& aLHS, const Maybe<T>& aRHS) {
|
|
|
|
return !(aLHS == aRHS);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Maybe<T> values are ordered in the same way T values are ordered, except that
|
|
|
|
* Nothing comes before anything else.
|
|
|
|
*/
|
|
|
|
template <typename T>
|
|
|
|
bool operator<(const Maybe<T>& aLHS, const Maybe<T>& aRHS) {
|
|
|
|
if (aLHS.isNothing()) {
|
|
|
|
return aRHS.isSome();
|
|
|
|
}
|
|
|
|
if (aRHS.isNothing()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return *aLHS < *aRHS;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
bool operator>(const Maybe<T>& aLHS, const Maybe<T>& aRHS) {
|
|
|
|
return !(aLHS < aRHS || aLHS == aRHS);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
bool operator<=(const Maybe<T>& aLHS, const Maybe<T>& aRHS) {
|
|
|
|
return aLHS < aRHS || aLHS == aRHS;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
bool operator>=(const Maybe<T>& aLHS, const Maybe<T>& aRHS) {
|
|
|
|
return !(aLHS < aRHS);
|
|
|
|
}
|
|
|
|
|
2019-01-19 02:21:46 +03:00
|
|
|
template <typename T>
|
|
|
|
inline void ImplCycleCollectionTraverse(
|
|
|
|
nsCycleCollectionTraversalCallback& aCallback, mozilla::Maybe<T>& aField,
|
|
|
|
const char* aName, uint32_t aFlags = 0) {
|
|
|
|
if (aField) {
|
|
|
|
ImplCycleCollectionTraverse(aCallback, aField.ref(), aName, aFlags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
inline void ImplCycleCollectionUnlink(mozilla::Maybe<T>& aField) {
|
|
|
|
if (aField) {
|
|
|
|
ImplCycleCollectionUnlink(aField.ref());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-28 02:10:28 +04:00
|
|
|
} // namespace mozilla
|
|
|
|
|
|
|
|
#endif /* mozilla_Maybe_h */
|