// Initializing |empty_| here instead of using default member initializing

// to avoid errors in g++ 4.8.

constexpr OptionalStorageBase() : empty_('\0') {}

template <class... Args>

constexpr explicit OptionalStorageBase(in_place_t, Args&&... args)

: is_populated_(true), value_(std::forward<Args>(args)...) {}

// When T is not trivially destructible we must call its

// destructor before deallocating its memory.

// Note that this hides the (implicitly declared) move constructor, which

// would be used for constexpr move constructor in OptionalStorage<T>.

// It is needed iff T is trivially move constructible. However, the current

// is_trivially_{copy,move}_constructible implementation requires

// is_trivially_destructible (which looks a bug, cf:

// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51452 and

// http://cplusplus.github.io/LWG/lwg-active.html#2116), so it is not

// necessary for this case at the moment. Please see also the destructor

// comment in "is_trivially_destructible = true" specialization below.

~OptionalStorageBase() {

if (is_populated_) value_.~T();

}

template <class... Args>

void Init(Args&&... args) {

DCHECK(!is_populated_);

::new (&value_) T(std::forward<Args>(args)...);

is_populated_ = true;

}

bool is_populated_ = false;

union {

// |empty_| exists so that the union will always be initialized, even when

// it doesn't contain a value. Union members must be initialized for the

// constructor to be 'constexpr'.

char empty_;

T value_;

};

DCHECK(!is_populated_);

::new (&value_) T(std::forward<Args>(args)...);

is_populated_ = true;

// This is no trivially {copy,move} constructible case. Other cases are

// defined below as specializations.

// Accessing the members of template base class requires explicit

// declaration.

using OptionalStorageBase<T>::is_populated_;

using OptionalStorageBase<T>::value_;

using OptionalStorageBase<T>::Init;

// Inherit constructors (specifically, the in_place constructor).

using OptionalStorageBase<T>::OptionalStorageBase;

// User defined constructor deletes the default constructor.

// Define it explicitly.

OptionalStorage() = default;

OptionalStorage(const OptionalStorage& other) V8_NOEXCEPT {

if (other.is_populated_) Init(other.value_);

}

OptionalStorage(OptionalStorage&& other) V8_NOEXCEPT {

if (other.is_populated_) Init(std::move(other.value_));

}

// This class provides implementation rather than public API, so everything

// should be hidden. Often we use composition, but we cannot in this case

// because of C++ language restriction.

protected:

constexpr OptionalBase() = default;

constexpr OptionalBase(const OptionalBase& other) V8_NOEXCEPT = default;

constexpr OptionalBase(OptionalBase&& other) V8_NOEXCEPT = default;

template <class... Args>

constexpr explicit OptionalBase(in_place_t, Args&&... args)

: storage_(in_place, std::forward<Args>(args)...) {}

// Implementation of converting constructors.

template <typename U>

explicit OptionalBase(const OptionalBase<U>& other) V8_NOEXCEPT {

if (other.storage_.is_populated_) storage_.Init(other.storage_.value_);

}

template <typename U>

explicit OptionalBase(OptionalBase<U>&& other) V8_NOEXCEPT {

if (other.storage_.is_populated_)

storage_.Init(std::move(other.storage_.value_));

}

~OptionalBase() = default;

OptionalBase& operator=(const OptionalBase& other) V8_NOEXCEPT {

CopyAssign(other);

return *this;

}

OptionalBase& operator=(OptionalBase&& other) V8_NOEXCEPT {

MoveAssign(std::move(other));

return *this;

}

template <typename U>

void CopyAssign(const OptionalBase<U>& other) {

if (other.storage_.is_populated_)

InitOrAssign(other.storage_.value_);

else

FreeIfNeeded();

}

template <typename U>

void MoveAssign(OptionalBase<U>&& other) {

if (other.storage_.is_populated_)

InitOrAssign(std::move(other.storage_.value_));

else

FreeIfNeeded();

}

template <typename U>

void InitOrAssign(U&& value) {

if (storage_.is_populated_)

storage_.value_ = std::forward<U>(value);

else

storage_.Init(std::forward<U>(value));

}

void FreeIfNeeded() {

if (!storage_.is_populated_) return;

storage_.value_.~T();

storage_.is_populated_ = false;

}

// For implementing conversion, allow access to other typed OptionalBase

// class.

template <typename U>

friend class OptionalBase;

OptionalStorage<T> storage_;

: std::integral_constant<

bool, std::is_constructible<T, Optional<U>&>::value ||

std::is_constructible<T, const Optional<U>&>::value ||

std::is_constructible<T, Optional<U>&&>::value ||

std::is_constructible<T, const Optional<U>&&>::value ||

std::is_convertible<Optional<U>&, T>::value ||

std::is_convertible<const Optional<U>&, T>::value ||

std::is_convertible<Optional<U>&&, T>::value ||

: std::integral_constant<

bool, IsConvertibleFromOptional<T, U>::value ||

std::is_assignable<T&, Optional<U>&>::value ||

std::is_assignable<T&, const Optional<U>&>::value ||

std::is_assignable<T&, Optional<U>&&>::value ||

// Tests if swap can be called. Check<T&>(0) returns true_type iff swap

// is available for T. Otherwise, Check's overload resolution falls back

// to Check(...) declared below thanks to SFINAE, so returns false_type.

template <typename T>

static auto Check(int i)

-> decltype(swap(std::declval<T>(), std::declval<T>()), std::true_type());

template <typename T>

static std::false_type Check(...);

// TODO(mlamouri): add the following assert when possible:

// static_assert(std::is_copy_constructible<T>::value,

// "T must be copy constructible");

static_assert(std::is_convertible<U, T>::value,

"U must be convertible to T");

return storage_.is_populated_

? storage_.value_

: static_cast<T>(std::forward<U>(default_value));

// TODO(mlamouri): add the following assert when possible:

// static_assert(std::is_move_constructible<T>::value,

// "T must be move constructible");

static_assert(std::is_convertible<U, T>::value,

"U must be convertible to T");

return storage_.is_populated_

? std::move(storage_.value_)

: static_cast<T>(std::forward<U>(default_value));

if (!storage_.is_populated_ && !other.storage_.is_populated_) return;

if (storage_.is_populated_ != other.storage_.is_populated_) {

if (storage_.is_populated_) {

other.storage_.Init(std::move(storage_.value_));

FreeIfNeeded();

} else {

storage_.Init(std::move(other.storage_.value_));

other.FreeIfNeeded();

}

return;

}

DCHECK(storage_.is_populated_ && other.storage_.is_populated_);

using std::swap;

swap(**this, *other);

FreeIfNeeded();

storage_.Init(il, std::forward<Args>(args)...);

return storage_.value_;