mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-22 10:29:35 +00:00
This can be used for in-place initialization of non-moveable types. For compilers that don't support variadic templates, only up to four arguments are supported. We can always add more, of course, but this should be good enough until we move to a later MSVC that has full support for variadic templates. Inspired by std::experimental::optional from the "Library Fundamentals" C++ TS. Reviewed by David Blaikie. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@218732 91177308-0d34-0410-b5e6-96231b3b80d8
257 lines
7.8 KiB
C++
257 lines
7.8 KiB
C++
//===-- Optional.h - Simple variant for passing optional values ---*- C++ -*-=//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file provides Optional, a template class modeled in the spirit of
|
|
// OCaml's 'opt' variant. The idea is to strongly type whether or not
|
|
// a value can be optional.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_ADT_OPTIONAL_H
|
|
#define LLVM_ADT_OPTIONAL_H
|
|
|
|
#include "llvm/ADT/None.h"
|
|
#include "llvm/Support/AlignOf.h"
|
|
#include "llvm/Support/Compiler.h"
|
|
#include <cassert>
|
|
#include <new>
|
|
#include <utility>
|
|
|
|
namespace llvm {
|
|
|
|
template<typename T>
|
|
class Optional {
|
|
AlignedCharArrayUnion<T> storage;
|
|
bool hasVal;
|
|
public:
|
|
typedef T value_type;
|
|
|
|
Optional(NoneType) : hasVal(false) {}
|
|
explicit Optional() : hasVal(false) {}
|
|
Optional(const T &y) : hasVal(true) {
|
|
new (storage.buffer) T(y);
|
|
}
|
|
Optional(const Optional &O) : hasVal(O.hasVal) {
|
|
if (hasVal)
|
|
new (storage.buffer) T(*O);
|
|
}
|
|
|
|
Optional(T &&y) : hasVal(true) {
|
|
new (storage.buffer) T(std::forward<T>(y));
|
|
}
|
|
Optional(Optional<T> &&O) : hasVal(O) {
|
|
if (O) {
|
|
new (storage.buffer) T(std::move(*O));
|
|
O.reset();
|
|
}
|
|
}
|
|
Optional &operator=(T &&y) {
|
|
if (hasVal)
|
|
**this = std::move(y);
|
|
else {
|
|
new (storage.buffer) T(std::move(y));
|
|
hasVal = true;
|
|
}
|
|
return *this;
|
|
}
|
|
Optional &operator=(Optional &&O) {
|
|
if (!O)
|
|
reset();
|
|
else {
|
|
*this = std::move(*O);
|
|
O.reset();
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
#if LLVM_HAS_VARIADIC_TEMPLATES
|
|
|
|
/// Create a new object by constructing it in place with the given arguments.
|
|
template<typename ...ArgTypes>
|
|
void emplace(ArgTypes &&...Args) {
|
|
reset();
|
|
hasVal = true;
|
|
new (storage.buffer) T(std::forward<ArgTypes>(Args)...);
|
|
}
|
|
|
|
#else
|
|
|
|
/// Create a new object by default-constructing it in place.
|
|
void emplace() {
|
|
reset();
|
|
hasVal = true;
|
|
new (storage.buffer) T();
|
|
}
|
|
|
|
/// Create a new object by constructing it in place with the given arguments.
|
|
template<typename T1>
|
|
void emplace(T1 &&A1) {
|
|
reset();
|
|
hasVal = true;
|
|
new (storage.buffer) T(std::forward<T1>(A1));
|
|
}
|
|
|
|
/// Create a new object by constructing it in place with the given arguments.
|
|
template<typename T1, typename T2>
|
|
void emplace(T1 &&A1, T2 &&A2) {
|
|
reset();
|
|
hasVal = true;
|
|
new (storage.buffer) T(std::forward<T1>(A1), std::forward<T2>(A2));
|
|
}
|
|
|
|
/// Create a new object by constructing it in place with the given arguments.
|
|
template<typename T1, typename T2, typename T3>
|
|
void emplace(T1 &&A1, T2 &&A2, T3 &&A3) {
|
|
reset();
|
|
hasVal = true;
|
|
new (storage.buffer) T(std::forward<T1>(A1), std::forward<T2>(A2),
|
|
std::forward<T3>(A3));
|
|
}
|
|
|
|
/// Create a new object by constructing it in place with the given arguments.
|
|
template<typename T1, typename T2, typename T3, typename T4>
|
|
void emplace(T1 &&A1, T2 &&A2, T3 &&A3, T4 &&A4) {
|
|
reset();
|
|
hasVal = true;
|
|
new (storage.buffer) T(std::forward<T1>(A1), std::forward<T2>(A2),
|
|
std::forward<T3>(A3), std::forward<T4>(A4));
|
|
}
|
|
|
|
#endif // LLVM_HAS_VARIADIC_TEMPLATES
|
|
|
|
static inline Optional create(const T* y) {
|
|
return y ? Optional(*y) : Optional();
|
|
}
|
|
|
|
// FIXME: these assignments (& the equivalent const T&/const Optional& ctors)
|
|
// could be made more efficient by passing by value, possibly unifying them
|
|
// with the rvalue versions above - but this could place a different set of
|
|
// requirements (notably: the existence of a default ctor) when implemented
|
|
// in that way. Careful SFINAE to avoid such pitfalls would be required.
|
|
Optional &operator=(const T &y) {
|
|
if (hasVal)
|
|
**this = y;
|
|
else {
|
|
new (storage.buffer) T(y);
|
|
hasVal = true;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
Optional &operator=(const Optional &O) {
|
|
if (!O)
|
|
reset();
|
|
else
|
|
*this = *O;
|
|
return *this;
|
|
}
|
|
|
|
void reset() {
|
|
if (hasVal) {
|
|
(**this).~T();
|
|
hasVal = false;
|
|
}
|
|
}
|
|
|
|
~Optional() {
|
|
reset();
|
|
}
|
|
|
|
const T* getPointer() const { assert(hasVal); return reinterpret_cast<const T*>(storage.buffer); }
|
|
T* getPointer() { assert(hasVal); return reinterpret_cast<T*>(storage.buffer); }
|
|
const T& getValue() const LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); }
|
|
T& getValue() LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); }
|
|
|
|
LLVM_EXPLICIT operator bool() const { return hasVal; }
|
|
bool hasValue() const { return hasVal; }
|
|
const T* operator->() const { return getPointer(); }
|
|
T* operator->() { return getPointer(); }
|
|
const T& operator*() const LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); }
|
|
T& operator*() LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); }
|
|
|
|
template <typename U>
|
|
LLVM_CONSTEXPR T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION {
|
|
return hasValue() ? getValue() : std::forward<U>(value);
|
|
}
|
|
|
|
#if LLVM_HAS_RVALUE_REFERENCE_THIS
|
|
T&& getValue() && { assert(hasVal); return std::move(*getPointer()); }
|
|
T&& operator*() && { assert(hasVal); return std::move(*getPointer()); }
|
|
|
|
template <typename U>
|
|
T getValueOr(U &&value) && {
|
|
return hasValue() ? std::move(getValue()) : std::forward<U>(value);
|
|
}
|
|
#endif
|
|
};
|
|
|
|
template <typename T> struct isPodLike;
|
|
template <typename T> struct isPodLike<Optional<T> > {
|
|
// An Optional<T> is pod-like if T is.
|
|
static const bool value = isPodLike<T>::value;
|
|
};
|
|
|
|
/// \brief Poison comparison between two \c Optional objects. Clients needs to
|
|
/// explicitly compare the underlying values and account for empty \c Optional
|
|
/// objects.
|
|
///
|
|
/// This routine will never be defined. It returns \c void to help diagnose
|
|
/// errors at compile time.
|
|
template<typename T, typename U>
|
|
void operator==(const Optional<T> &X, const Optional<U> &Y);
|
|
|
|
/// \brief Poison comparison between two \c Optional objects. Clients needs to
|
|
/// explicitly compare the underlying values and account for empty \c Optional
|
|
/// objects.
|
|
///
|
|
/// This routine will never be defined. It returns \c void to help diagnose
|
|
/// errors at compile time.
|
|
template<typename T, typename U>
|
|
void operator!=(const Optional<T> &X, const Optional<U> &Y);
|
|
|
|
/// \brief Poison comparison between two \c Optional objects. Clients needs to
|
|
/// explicitly compare the underlying values and account for empty \c Optional
|
|
/// objects.
|
|
///
|
|
/// This routine will never be defined. It returns \c void to help diagnose
|
|
/// errors at compile time.
|
|
template<typename T, typename U>
|
|
void operator<(const Optional<T> &X, const Optional<U> &Y);
|
|
|
|
/// \brief Poison comparison between two \c Optional objects. Clients needs to
|
|
/// explicitly compare the underlying values and account for empty \c Optional
|
|
/// objects.
|
|
///
|
|
/// This routine will never be defined. It returns \c void to help diagnose
|
|
/// errors at compile time.
|
|
template<typename T, typename U>
|
|
void operator<=(const Optional<T> &X, const Optional<U> &Y);
|
|
|
|
/// \brief Poison comparison between two \c Optional objects. Clients needs to
|
|
/// explicitly compare the underlying values and account for empty \c Optional
|
|
/// objects.
|
|
///
|
|
/// This routine will never be defined. It returns \c void to help diagnose
|
|
/// errors at compile time.
|
|
template<typename T, typename U>
|
|
void operator>=(const Optional<T> &X, const Optional<U> &Y);
|
|
|
|
/// \brief Poison comparison between two \c Optional objects. Clients needs to
|
|
/// explicitly compare the underlying values and account for empty \c Optional
|
|
/// objects.
|
|
///
|
|
/// This routine will never be defined. It returns \c void to help diagnose
|
|
/// errors at compile time.
|
|
template<typename T, typename U>
|
|
void operator>(const Optional<T> &X, const Optional<U> &Y);
|
|
|
|
} // end llvm namespace
|
|
|
|
#endif
|