maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Add all the relational operators to std::experimental::optional. Also update bad_optional_access to match the Library Fundamentals draft standard. This is not all of the upcoming changes to optional, though. 

llvm-svn: 223775
This commit is contained in:
Marshall Clow 2014-12-09 14:49:17 +00:00
parent f57ac3bd22
commit e61fba3b70
24 changed files with 1047 additions and 266 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

407
libcxx/include/experimental/optional
View File

@ -16,131 +16,147 @@
// C++1y
#include <initializer_list>
namespace std { namespace experimental { inline namespace fundamentals_v1 {
namespace std { namespace experimental {
// 5.3, optional for object types
template <class T> class optional;
// optional for object types
template <class T>
class optional
{
public:
typedef T value_type;
// 5.4, In-place construction
struct in_place_t{};
constexpr in_place_t in_place{};
// constructors
constexpr optional() noexcept;
constexpr optional(nullopt_t) noexcept;
optional(const optional&);
optional(optional&&) noexcept(is_nothrow_move_constructible<T>::value);
constexpr optional(const T&);
constexpr optional(T&&);
template <class... Args> constexpr explicit optional(in_place_t, Args&&...);
template <class U, class... Args>
constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...);
// 5.5, No-value state indicator
struct nullopt_t{see below};
constexpr nullopt_t nullopt(unspecified);
// destructor
~optional();
// 5.6, Class bad_optional_access
class bad_optional_access;
// assignment
optional& operator=(nullopt_t) noexcept;
optional& operator=(const optional&);
optional& operator=(optional&&)
noexcept(is_nothrow_move_assignable<T>::value &&
is_nothrow_move_constructible<T>::value);
template <class U> optional& operator=(U&&);
template <class... Args> void emplace(Args&&...);
template <class U, class... Args> void emplace(initializer_list<U>, Args&&...);
// 5.7, Relational operators
template <class T>
constexpr bool operator==(const optional<T>&, const optional<T>&);
template <class T>
constexpr bool operator!=(const optional<T>&, const optional<T>&);
template <class T>
constexpr bool operator<(const optional<T>&, const optional<T>&);
template <class T>
constexpr bool operator>(const optional<T>&, const optional<T>&);
template <class T>
constexpr bool operator<=(const optional<T>&, const optional<T>&);
template <class T>
constexpr bool operator>=(const optional<T>&, const optional<T>&);
// swap
void swap(optional&)
noexcept(is_nothrow_move_constructible<T>::value &&
noexcept(swap(declval<T&>(), declval<T&>())));
// 5.8, Comparison with nullopt
template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept;
template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept;
template <class T> constexpr bool operator!=(const optional<T>&, nullopt_t) noexcept;
template <class T> constexpr bool operator!=(nullopt_t, const optional<T>&) noexcept;
template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept;
template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept;
template <class T> constexpr bool operator<=(const optional<T>&, nullopt_t) noexcept;
template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept;
template <class T> constexpr bool operator>(const optional<T>&, nullopt_t) noexcept;
template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept;
template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept;
template <class T> constexpr bool operator>=(nullopt_t, const optional<T>&) noexcept;
// observers
constexpr T const* operator->() const;
T* operator->();
constexpr T const& operator*() const;
T& operator*();
constexpr explicit operator bool() const noexcept;
constexpr T const& value() const;
T& value();
template <class U> constexpr T value_or(U&&) const&;
template <class U> T value_or(U&&) &&;
};
// 5.9, Comparison with T
template <class T> constexpr bool operator==(const optional<T>&, const T&);
template <class T> constexpr bool operator==(const T&, const optional<T>&);
template <class T> constexpr bool operator!=(const optional<T>&, const T&);
template <class T> constexpr bool operator!=(const T&, const optional<T>&);
template <class T> constexpr bool operator<(const optional<T>&, const T&);
template <class T> constexpr bool operator<(const T&, const optional<T>&);
template <class T> constexpr bool operator<=(const optional<T>&, const T&);
template <class T> constexpr bool operator<=(const T&, const optional<T>&);
template <class T> constexpr bool operator>(const optional<T>&, const T&);
template <class T> constexpr bool operator>(const T&, const optional<T>&);
template <class T> constexpr bool operator>=(const optional<T>&, const T&);
template <class T> constexpr bool operator>=(const T&, const optional<T>&);
// In-place construction
struct in_place_t{};
constexpr in_place_t in_place{};
// 5.10, Specialized algorithms
template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below);
template <class T> constexpr optional<see below> make_optional(T&&);
// Disengaged state indicator
struct nullopt_t{see below};
constexpr nullopt_t nullopt(unspecified);
template <class T>
class optional
{
public:
typedef T value_type;
// class bad_optional_access
class bad_optional_access
: public logic_error
{
public:
explicit bad_optional_access(const string& what_arg);
explicit bad_optional_access(const char* what_arg);
};
// 5.3.1, Constructors
constexpr optional() noexcept;
constexpr optional(nullopt_t) noexcept;
optional(const optional&);
optional(optional&&) noexcept(see below);
constexpr optional(const T&);
constexpr optional(T&&);
template <class... Args> constexpr explicit optional(in_place_t, Args&&...);
template <class U, class... Args>
constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...);
// Relational operators
template <class T> constexpr bool operator==(const optional<T>&, const optional<T>&);
template <class T> constexpr bool operator< (const optional<T>&, const optional<T>&);
// 5.3.2, Destructor
~optional();
// Comparison with nullopt
template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept;
template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept;
template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept;
template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept;
// 5.3.3, Assignment
optional& operator=(nullopt_t) noexcept;
optional& operator=(const optional&);
optional& operator=(optional&&) noexcept(see below);
template <class U> optional& operator=(U&&);
template <class... Args> void emplace(Args&&...);
template <class U, class... Args>
void emplace(initializer_list<U>, Args&&...);
// Comparison with T
template <class T> constexpr bool operator==(const optional<T>&, const T&);
template <class T> constexpr bool operator==(const T&, const optional<T>&);
template <class T> constexpr bool operator<(const optional<T>&, const T&);
template <class T> constexpr bool operator<(const T&, const optional<T>&);
// 5.3.4, Swap
void swap(optional&) noexcept(see below);
// Specialized algorithms
template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below);
template <class T> constexpr optional<typename decay<T>::type> make_optional(T&&);
// 5.3.5, Observers
constexpr T const* operator ->() const;
constexpr T* operator ->();
constexpr T const& operator *() const &;
constexpr T& operator *() &;
constexpr T&& operator *() &&;
constexpr const T&& operator *() const &&;
constexpr explicit operator bool() const noexcept;
constexpr T const& value() const &;
constexpr T& value() &;
constexpr T&& value() &&;
constexpr const T&& value() const &&;
template <class U> constexpr T value_or(U&&) const &;
template <class U> constexpr T value_or(U&&) &&;
// hash support
template <class T> struct hash;
template <class T> struct hash<optional<T>>;
private:
T* val; // exposition only
};
}} // std::experimental
} // namespace fundamentals_v1
} // namespace experimental
// 5.11, Hash support
template <class T> struct hash;
template <class T> struct hash<experimental::optional<T>>;
} // namespace std
*/
#include <__config>
#include <experimental/__config>
#include <functional>
#include <stdexcept>
namespace std { namespace experimental {
_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
class _LIBCPP_EXCEPTION_ABI bad_optional_access
: public logic_error
: public std::logic_error
{
public:
#if _LIBCPP_STD_VER > 11
_LIBCPP_INLINE_VISIBILITY explicit bad_optional_access(const string& __arg)
: logic_error(__arg) {}
_LIBCPP_INLINE_VISIBILITY explicit bad_optional_access(const char* __arg)
: logic_error(__arg) {}
_LIBCPP_INLINE_VISIBILITY bad_optional_access(const bad_optional_access&) noexcept = default;
_LIBCPP_INLINE_VISIBILITY bad_optional_access& operator=(const bad_optional_access&) noexcept = default;
#else
private:
bad_optional_access(const bad_optional_access&);
bad_optional_access& operator=(const bad_optional_access&);
public:
#endif // _LIBCPP_STD_VER > 11
// Get the key function ~bad_optional_access() into the dylib even if not compiling for C++1y
bad_optional_access() : std::logic_error("Bad optional Access") {}
// Get the key function ~bad_optional_access() into the dylib
virtual ~bad_optional_access() _NOEXCEPT;
};
}} // std::experimental
_LIBCPP_END_NAMESPACE_EXPERIMENTAL
#if _LIBCPP_STD_VER > 11
@ -148,16 +164,14 @@ public:
#include <type_traits>
#include <new>
#include <__functional_base>
#include <__undef_min_max>
#include <__debug>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
namespace std { namespace experimental { inline namespace __library_fundamentals_v1 {
_LIBCPP_BEGIN_NAMESPACE_LFTS
struct in_place_t {};
constexpr in_place_t in_place{};
@ -503,7 +517,7 @@ public:
constexpr value_type const& value() const
{
if (!this->__engaged_)
throw bad_optional_access("optional<T>::value: not engaged");
throw bad_optional_access();
return this->__val_;
}
@ -511,7 +525,7 @@ public:
value_type& value()
{
if (!this->__engaged_)
throw bad_optional_access("optional<T>::value: not engaged");
throw bad_optional_access();
return this->__val_;
}
@ -556,6 +570,7 @@ private:
}
};
// Comparisons between optionals
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
@ -569,6 +584,15 @@ operator==(const optional<_Tp>& __x, const optional<_Tp>& __y)
return *__x == *__y;
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator!=(const optional<_Tp>& __x, const optional<_Tp>& __y)
{
return !(__x == __y);
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
@ -579,9 +603,38 @@ operator<(const optional<_Tp>& __x, const optional<_Tp>& __y)
return false;
if (!static_cast<bool>(__x))
return true;
return less<_Tp>{}(*__x, *__y);
return *__x < *__y;
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>(const optional<_Tp>& __x, const optional<_Tp>& __y)
{
return __y < __x;
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<=(const optional<_Tp>& __x, const optional<_Tp>& __y)
{
return !(__y < __x);
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>=(const optional<_Tp>& __x, const optional<_Tp>& __y)
{
return !(__x < __y);
}
// Comparisons with nullopt
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
@ -600,6 +653,24 @@ operator==(nullopt_t, const optional<_Tp>& __x) noexcept
return !static_cast<bool>(__x);
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator!=(const optional<_Tp>& __x, nullopt_t) noexcept
{
return static_cast<bool>(__x);
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator!=(nullopt_t, const optional<_Tp>& __x) noexcept
{
return static_cast<bool>(__x);
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
@ -618,6 +689,61 @@ operator<(nullopt_t, const optional<_Tp>& __x) noexcept
return static_cast<bool>(__x);
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<=(const optional<_Tp>& __x, nullopt_t) noexcept
{
return !static_cast<bool>(__x);
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<=(nullopt_t, const optional<_Tp>& __x) noexcept
{
return true;
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>(const optional<_Tp>& __x, nullopt_t) noexcept
{
return static_cast<bool>(__x);
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>(nullopt_t, const optional<_Tp>& __x) noexcept
{
return false;
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>=(const optional<_Tp>&, nullopt_t) noexcept
{
return true;
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>=(nullopt_t, const optional<_Tp>& __x) noexcept
{
return !static_cast<bool>(__x);
}
// Comparisons with T
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
@ -636,6 +762,24 @@ operator==(const _Tp& __v, const optional<_Tp>& __x)
return static_cast<bool>(__x) ? *__x == __v : false;
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator!=(const optional<_Tp>& __x, const _Tp& __v)
{
return static_cast<bool>(__x) ? !(*__x == __v) : true;
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator!=(const _Tp& __v, const optional<_Tp>& __x)
{
return static_cast<bool>(__x) ? !(*__x == __v) : true;
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
@ -654,6 +798,61 @@ operator<(const _Tp& __v, const optional<_Tp>& __x)
return static_cast<bool>(__x) ? less<_Tp>{}(__v, *__x) : false;
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<=(const optional<_Tp>& __x, const _Tp& __v)
{
return !(__x > __v);
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator<=(const _Tp& __v, const optional<_Tp>& __x)
{
return !(__v > __x);
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>(const optional<_Tp>& __x, const _Tp& __v)
{
return static_cast<bool>(__x) ? __v < __x : false;
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>(const _Tp& __v, const optional<_Tp>& __x)
{
return static_cast<bool>(__x) ? __x < __v : true;
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>=(const optional<_Tp>& __x, const _Tp& __v)
{
return !(__x < __v);
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr
bool
operator>=(const _Tp& __v, const optional<_Tp>& __x)
{
return !(__v < __x);
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
void
@ -671,7 +870,7 @@ make_optional(_Tp&& __v)
return optional<typename decay<_Tp>::type>(_VSTD::forward<_Tp>(__v));
}
}}} // namespace std::experimental::__library_fundamentals_v1
_LIBCPP_END_NAMESPACE_LFTS
_LIBCPP_BEGIN_NAMESPACE_STD

5
libcxx/src/optional.cpp
View File

@ -9,8 +9,7 @@
#include "experimental/optional"
namespace std // purposefully not using versioning namespace
{ namespace experimental {
_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
@ -22,4 +21,4 @@ bad_optional_access::~bad_optional_access() _NOEXCEPT = default;
#endif
}} // std::experimental
_LIBCPP_END_NAMESPACE_EXPERIMENTAL

29
libcxx/test/utilities/optional/optional.bad_optional_access/char_pointer.pass.cpp
View File

@ -1,29 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <optional>
// class bad_optional_access;
// explicit bad_optional_access(const char* what_arg);
#include <experimental/optional>
#include <string>
#include <cstring>
#include <cassert>
int main()
{
#if _LIBCPP_STD_VER > 11
using std::experimental::bad_optional_access;
const char* s = "message";
bad_optional_access e(s);
assert(std::strcmp(e.what(), s) == 0);
#endif // _LIBCPP_STD_VER > 11
}

35
libcxx/test/utilities/optional/optional.bad_optional_access/copy_assign.pass.cpp
View File

@ -1,35 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <optional>
// class bad_optional_access;
// bad_optional_access& operator=(const bad_optional_access&);
#include <experimental/optional>
#include <string>
#include <cstring>
#include <type_traits>
#include <cassert>
int main()
{
#if _LIBCPP_STD_VER > 11
using std::experimental::bad_optional_access;
static_assert(std::is_nothrow_copy_assignable<bad_optional_access>::value, "");
const std::string s1("one message");
const std::string s2("another message");
bad_optional_access e1(s1);
bad_optional_access e2(s2);
assert(std::strcmp(e1.what(), e2.what()) != 0);
e1 = e2;
assert(std::strcmp(e1.what(), e2.what()) == 0);
#endif // _LIBCPP_STD_VER > 11
}

32
libcxx/test/utilities/optional/optional.bad_optional_access/copy_ctor.pass.cpp
View File

@ -1,32 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <optional>
// class bad_optional_access;
// bad_optional_access(const bad_optional_access&);
#include <experimental/optional>
#include <string>
#include <cstring>
#include <type_traits>
#include <cassert>
int main()
{
#if _LIBCPP_STD_VER > 11
using std::experimental::bad_optional_access;
static_assert(std::is_nothrow_copy_constructible<bad_optional_access>::value, "");
const std::string s("another message");
bad_optional_access e1(s);
bad_optional_access e2 = e1;
assert(std::strcmp(e1.what(), e2.what()) == 0);
#endif // _LIBCPP_STD_VER > 11
}

5
libcxx/test/utilities/optional/optional.bad_optional_access/default.pass.cpp
View File

@ -9,7 +9,7 @@
// <optional>
// class bad_optional_access is not default constructible
// class bad_optional_access is default constructible
#include <experimental/optional>
#include <type_traits>
@ -18,7 +18,6 @@ int main()
{
#if _LIBCPP_STD_VER > 11
using std::experimental::bad_optional_access;
static_assert(!std::is_default_constructible<bad_optional_access>::value, "");
bad_optional_access ex;
#endif // _LIBCPP_STD_VER > 11
}

29
libcxx/test/utilities/optional/optional.bad_optional_access/string.pass.cpp
View File

@ -1,29 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <optional>
// class bad_optional_access;
// explicit bad_optional_access(const string& what_arg);
#include <experimental/optional>
#include <string>
#include <cstring>
#include <cassert>
int main()
{
#if _LIBCPP_STD_VER > 11
using std::experimental::bad_optional_access;
const std::string s("message");
bad_optional_access e(s);
assert(std::strcmp(e.what(), s.c_str()) == 0);
#endif // _LIBCPP_STD_VER > 11
}

16
libcxx/test/utilities/optional/optional.comp_with_t/equal.pass.cpp
View File

@ -38,21 +38,21 @@ int main()
typedef optional<T> O;
constexpr T val(2);
constexpr O o1; // disengaged
constexpr O o2{1}; // engaged
constexpr O o1; // disengaged
constexpr O o2{1}; // engaged
constexpr O o3{val}; // engaged
static_assert ( !(o1 == T(1)), "" );
static_assert ( o2 == T(1), "" );
static_assert ( (o2 == T(1)), "" );
static_assert ( !(o3 == T(1)), "" );
static_assert ( o3 == T(2) , "" );
static_assert ( o3 == val, "" );
static_assert ( (o3 == T(2)), "" );
static_assert ( (o3 == val), "" );
static_assert ( !(T(1) == o1), "" );
static_assert ( T(1) == o2, "" );
static_assert ( (T(1) == o2), "" );
static_assert ( !(T(1) == o3), "" );
static_assert ( T(2) == o3 , "" );
static_assert ( val == o3 , "" );
static_assert ( (T(2) == o3), "" );
static_assert ( (val == o3), "" );
}
#endif
}

61
libcxx/test/utilities/optional/optional.comp_with_t/greater.pass.cpp Normal file
View File

@ -0,0 +1,61 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <optional>
// template <class T> constexpr bool operator>(const optional<T>& x, const T& v);
// template <class T> constexpr bool operator>(const T& v, const optional<T>& x);
#include <experimental/optional>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional;
struct X
{
int i_;
constexpr X(int i) : i_(i) {}
};
constexpr bool operator < ( const X &lhs, const X &rhs )
{ return lhs.i_ < rhs.i_ ; }
#endif
int main()
{
#if _LIBCPP_STD_VER > 11
{
typedef X T;
typedef optional<T> O;
constexpr T val(2);
constexpr O o1; // disengaged
constexpr O o2{1}; // engaged
constexpr O o3{val}; // engaged
static_assert ( !(o1 > T(1)), "" );
static_assert ( !(o2 > T(1)), "" ); // equal
static_assert ( (o3 > T(1)), "" );
static_assert ( !(o2 > val), "" );
static_assert ( !(o3 > val), "" ); // equal
static_assert ( !(o3 > T(3)), "" );
static_assert ( (T(1) > o1), "" );
static_assert ( !(T(1) > o2), "" ); // equal
static_assert ( !(T(1) > o3), "" );
static_assert ( (val > o2), "" );
static_assert ( !(val > o3), "" ); // equal
static_assert ( (T(3) > o3), "" );
}
#endif
}

61
libcxx/test/utilities/optional/optional.comp_with_t/greater_equal.pass.cpp Normal file
View File

@ -0,0 +1,61 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <optional>
// template <class T> constexpr bool operator>=(const optional<T>& x, const T& v);
// template <class T> constexpr bool operator>=(const T& v, const optional<T>& x);
#include <experimental/optional>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional;
struct X
{
int i_;
constexpr X(int i) : i_(i) {}
};
constexpr bool operator < ( const X &lhs, const X &rhs )
{ return lhs.i_ < rhs.i_ ; }
#endif
int main()
{
#if _LIBCPP_STD_VER > 11
{
typedef X T;
typedef optional<T> O;
constexpr T val(2);
constexpr O o1; // disengaged
constexpr O o2{1}; // engaged
constexpr O o3{val}; // engaged
static_assert ( !(o1 >= T(1)), "" );
static_assert ( (o2 >= T(1)), "" ); // equal
static_assert ( (o3 >= T(1)), "" );
static_assert ( !(o2 >= val), "" );
static_assert ( (o3 >= val), "" ); // equal
static_assert ( !(o3 >= T(3)), "" );
static_assert ( (T(1) >= o1), "" );
static_assert ( (T(1) >= o2), "" ); // equal
static_assert ( !(T(1) >= o3), "" );
static_assert ( (val >= o2), "" );
static_assert ( (val >= o3), "" ); // equal
static_assert ( (T(3) >= o3), "" );
}
#endif
}

61
libcxx/test/utilities/optional/optional.comp_with_t/less_equal.pass.cpp Normal file
View File

@ -0,0 +1,61 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <optional>
// template <class T> constexpr bool operator<=(const optional<T>& x, const T& v);
// template <class T> constexpr bool operator<=(const T& v, const optional<T>& x);
#include <experimental/optional>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional;
struct X
{
int i_;
constexpr X(int i) : i_(i) {}
};
constexpr bool operator < ( const X &lhs, const X &rhs )
{ return lhs.i_ < rhs.i_ ; }
#endif
int main()
{
#if _LIBCPP_STD_VER > 11
{
typedef X T;
typedef optional<T> O;
constexpr T val(2);
constexpr O o1; // disengaged
constexpr O o2{1}; // engaged
constexpr O o3{val}; // engaged
static_assert ( (o1 <= T(1)), "" );
static_assert ( (o2 <= T(1)), "" ); // equal
static_assert ( !(o3 <= T(1)), "" );
static_assert ( (o2 <= val), "" );
static_assert ( (o3 <= val), "" ); // equal
static_assert ( (o3 <= T(3)), "" );
static_assert ( !(T(1) <= o1), "" );
static_assert ( (T(1) <= o2), "" ); // equal
static_assert ( (T(1) <= o3), "" );
static_assert ( !(val <= o2), "" );
static_assert ( (val <= o3), "" ); // equal
static_assert ( !(T(3) <= o3), "" );
}
#endif
}

24
libcxx/test/utilities/optional/optional.comp_with_t/less_than.pass.cpp
View File

@ -37,24 +37,24 @@ int main()
{
typedef X T;
typedef optional<T> O;
constexpr T val(2);
constexpr O o1; // disengaged
constexpr O o2{1}; // engaged
constexpr O o1; // disengaged
constexpr O o2{1}; // engaged
constexpr O o3{val}; // engaged
static_assert ( o1 < T(1) , "" );
static_assert ( !(o2 < T(1)), "" );
static_assert ( (o1 < T(1)), "" );
static_assert ( !(o2 < T(1)), "" ); // equal
static_assert ( !(o3 < T(1)), "" );
static_assert ( o2 < T(2) , "" );
static_assert ( o2 < T(val), "" );
static_assert ( o3 < T(3) , "" );
static_assert ( (o2 < val), "" );
static_assert ( !(o3 < val), "" ); // equal
static_assert ( (o3 < T(3)), "" );
static_assert ( !(T(1) < o1), "" );
static_assert ( !(T(1) < o2), "" );
static_assert ( T(1) < o3 , "" );
static_assert ( !(T(2) < o2), "" );
static_assert (!(T(val) < o2), "" );
static_assert ( !(T(1) < o2), "" ); // equal
static_assert ( (T(1) < o3), "" );
static_assert ( !(val < o2), "" );
static_assert ( !(val < o3), "" ); // equal
static_assert ( !(T(3) < o3), "" );
}
#endif

58
libcxx/test/utilities/optional/optional.comp_with_t/not_equal.pass.cpp Normal file
View File

@ -0,0 +1,58 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <optional>
// template <class T> constexpr bool operator!=(const optional<T>& x, const T& v);
// template <class T> constexpr bool operator!=(const T& v, const optional<T>& x);
#include <experimental/optional>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional;
struct X
{
int i_;
constexpr X(int i) : i_(i) {}
};
constexpr bool operator == ( const X &lhs, const X &rhs )
{ return lhs.i_ == rhs.i_ ; }
#endif
int main()
{
#if _LIBCPP_STD_VER > 11
{
typedef X T;
typedef optional<T> O;
constexpr T val(2);
constexpr O o1; // disengaged
constexpr O o2{1}; // engaged
constexpr O o3{val}; // engaged
static_assert ( (o1 != T(1)), "" );
static_assert ( !(o2 != T(1)), "" );
static_assert ( (o3 != T(1)), "" );
static_assert ( !(o3 != T(2)), "" );
static_assert ( !(o3 != val), "" );
static_assert ( (T(1) != o1), "" );
static_assert ( !(T(1) != o2), "" );
static_assert ( (T(1) != o3), "" );
static_assert ( !(T(2) != o3), "" );
static_assert ( !(val != o3), "" );
}
#endif
}

4
libcxx/test/utilities/optional/optional.nullops/eqaul.pass.cpp → libcxx/test/utilities/optional/optional.nullops/equal.pass.cpp
View File

@ -29,9 +29,9 @@ int main()
constexpr O o1; // disengaged
constexpr O o2{1}; // engaged
static_assert ( nullopt == o1 , "" );
static_assert ( (nullopt == o1), "" );
static_assert ( !(nullopt == o2), "" );
static_assert ( o1 == nullopt , "" );
static_assert ( (o1 == nullopt), "" );
static_assert ( !(o2 == nullopt), "" );
static_assert (noexcept(nullopt == o1), "");

41
libcxx/test/utilities/optional/optional.nullops/greater.pass.cpp Normal file
View File

@ -0,0 +1,41 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <optional>
// template <class T> constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept;
// template <class T> constexpr bool operator>(nullopt_t, const optional<T>& x) noexcept;
#include <experimental/optional>
int main()
{
#if _LIBCPP_STD_VER > 11
using std::experimental::optional;
using std::experimental::nullopt_t;
using std::experimental::nullopt;
{
typedef int T;
typedef optional<T> O;
constexpr O o1; // disengaged
constexpr O o2{1}; // engaged
static_assert ( !(nullopt > o1), "" );
static_assert ( !(nullopt > o2), "" );
static_assert ( !(o1 > nullopt), "" );
static_assert ( (o2 > nullopt), "" );
static_assert (noexcept(nullopt > o1), "");
static_assert (noexcept(o1 > nullopt), "");
}
#endif
}

41
libcxx/test/utilities/optional/optional.nullops/greater_equal.pass.cpp Normal file
View File

@ -0,0 +1,41 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <optional>
// template <class T> constexpr bool operator>=(const optional<T>& x, nullopt_t) noexcept;
// template <class T> constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept;
#include <experimental/optional>
int main()
{
#if _LIBCPP_STD_VER > 11
using std::experimental::optional;
using std::experimental::nullopt_t;
using std::experimental::nullopt;
{
typedef int T;
typedef optional<T> O;
constexpr O o1; // disengaged
constexpr O o2{1}; // engaged
static_assert ( (nullopt >= o1), "" );
static_assert ( !(nullopt >= o2), "" );
static_assert ( (o1 >= nullopt), "" );
static_assert ( (o2 >= nullopt), "" );
static_assert (noexcept(nullopt >= o1), "");
static_assert (noexcept(o1 >= nullopt), "");
}
#endif
}

41
libcxx/test/utilities/optional/optional.nullops/less_equal.pass.cpp Normal file
View File

@ -0,0 +1,41 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <optional>
// template <class T> constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept;
// template <class T> constexpr bool operator<=(nullopt_t, const optional<T>& x) noexcept;
#include <experimental/optional>
int main()
{
#if _LIBCPP_STD_VER > 11
using std::experimental::optional;
using std::experimental::nullopt_t;
using std::experimental::nullopt;
{
typedef int T;
typedef optional<T> O;
constexpr O o1; // disengaged
constexpr O o2{1}; // engaged
static_assert ( (nullopt <= o1), "" );
static_assert ( (nullopt <= o2), "" );
static_assert ( (o1 <= nullopt), "" );
static_assert ( !(o2 <= nullopt), "" );
static_assert (noexcept(nullopt <= o1), "");
static_assert (noexcept(o1 <= nullopt), "");
}
#endif
}

2
libcxx/test/utilities/optional/optional.nullops/less_than.pass.cpp
View File

@ -30,7 +30,7 @@ int main()
constexpr O o2{1}; // engaged
static_assert ( !(nullopt < o1), "" );
static_assert ( nullopt < o2 , "" );
static_assert ( (nullopt < o2), "" );
static_assert ( !(o1 < nullopt), "" );
static_assert ( !(o2 < nullopt), "" );

41
libcxx/test/utilities/optional/optional.nullops/not_equal.pass.cpp Normal file
View File

@ -0,0 +1,41 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <optional>
// template <class T> constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept;
// template <class T> constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept;
#include <experimental/optional>
int main()
{
#if _LIBCPP_STD_VER > 11
using std::experimental::optional;
using std::experimental::nullopt_t;
using std::experimental::nullopt;
{
typedef int T;
typedef optional<T> O;
constexpr O o1; // disengaged
constexpr O o2{1}; // engaged
static_assert ( !(nullopt != o1), "" );
static_assert ( (nullopt != o2), "" );
static_assert ( !(o1 != nullopt), "" );
static_assert ( (o2 != nullopt), "" );
static_assert (noexcept(nullopt != o1), "");
static_assert (noexcept(o1 != nullopt), "");
}
#endif
}

75
libcxx/test/utilities/optional/optional.relops/greater_equal.pass.cpp Normal file
View File

@ -0,0 +1,75 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <optional>
// template <class T> constexpr bool operator>= (const optional<T>& x, const optional<T>& y);
#include <experimental/optional>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional;
struct X
{
int i_;
constexpr X(int i) : i_(i) {}
};
constexpr bool operator < ( const X &lhs, const X &rhs )
{ return lhs.i_ < rhs.i_ ; }
#endif
int main()
{
#if _LIBCPP_STD_VER > 11
{
typedef optional<X> O;
constexpr O o1; // disengaged
constexpr O o2; // disengaged
constexpr O o3{1}; // engaged
constexpr O o4{2}; // engaged
constexpr O o5{1}; // engaged
static_assert ( (o1 >= o1), "" );
static_assert ( (o1 >= o2), "" );
static_assert ( !(o1 >= o3), "" );
static_assert ( !(o1 >= o4), "" );
static_assert ( !(o1 >= o5), "" );
static_assert ( (o2 >= o1), "" );
static_assert ( (o2 >= o2), "" );
static_assert ( !(o2 >= o3), "" );
static_assert ( !(o2 >= o4), "" );
static_assert ( !(o2 >= o5), "" );
static_assert ( (o3 >= o1), "" );
static_assert ( (o3 >= o2), "" );
static_assert ( (o3 >= o3), "" );
static_assert ( !(o3 >= o4), "" );
static_assert ( (o3 >= o5), "" );
static_assert ( (o4 >= o1), "" );
static_assert ( (o4 >= o2), "" );
static_assert ( (o4 >= o3), "" );
static_assert ( (o4 >= o4), "" );
static_assert ( (o4 >= o5), "" );
static_assert ( (o5 >= o1), "" );
static_assert ( (o5 >= o2), "" );
static_assert ( (o5 >= o3), "" );
static_assert ( !(o5 >= o4), "" );
static_assert ( (o5 >= o5), "" );
}
#endif
}

75
libcxx/test/utilities/optional/optional.relops/greater_than.pass.cpp Normal file
View File

@ -0,0 +1,75 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <optional>
// template <class T> constexpr bool operator> (const optional<T>& x, const optional<T>& y);
#include <experimental/optional>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional;
struct X
{
int i_;
constexpr X(int i) : i_(i) {}
};
constexpr bool operator < ( const X &lhs, const X &rhs )
{ return lhs.i_ < rhs.i_ ; }
#endif
int main()
{
#if _LIBCPP_STD_VER > 11
{
typedef optional<X> O;
constexpr O o1; // disengaged
constexpr O o2; // disengaged
constexpr O o3{1}; // engaged
constexpr O o4{2}; // engaged
constexpr O o5{1}; // engaged
static_assert ( !(o1 > o1), "" );
static_assert ( !(o1 > o2), "" );
static_assert ( !(o1 > o3), "" );
static_assert ( !(o1 > o4), "" );
static_assert ( !(o1 > o5), "" );
static_assert ( !(o2 > o1), "" );
static_assert ( !(o2 > o2), "" );
static_assert ( !(o2 > o3), "" );
static_assert ( !(o2 > o4), "" );
static_assert ( !(o2 > o5), "" );
static_assert ( (o3 > o1), "" );
static_assert ( (o3 > o2), "" );
static_assert ( !(o3 > o3), "" );
static_assert ( !(o3 > o4), "" );
static_assert ( !(o3 > o5), "" );
static_assert ( (o4 > o1), "" );
static_assert ( (o4 > o2), "" );
static_assert ( (o4 > o3), "" );
static_assert ( !(o4 > o4), "" );
static_assert ( (o4 > o5), "" );
static_assert ( (o5 > o1), "" );
static_assert ( (o5 > o2), "" );
static_assert ( !(o5 > o3), "" );
static_assert ( !(o5 > o4), "" );
static_assert ( !(o5 > o5), "" );
}
#endif
}

75
libcxx/test/utilities/optional/optional.relops/less_equal.pass.cpp Normal file
View File

@ -0,0 +1,75 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <optional>
// template <class T> constexpr bool operator<= (const optional<T>& x, const optional<T>& y);
#include <experimental/optional>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional;
struct X
{
int i_;
constexpr X(int i) : i_(i) {}
};
constexpr bool operator < ( const X &lhs, const X &rhs )
{ return lhs.i_ < rhs.i_ ; }
#endif
int main()
{
#if _LIBCPP_STD_VER > 11
{
typedef optional<X> O;
constexpr O o1; // disengaged
constexpr O o2; // disengaged
constexpr O o3{1}; // engaged
constexpr O o4{2}; // engaged
constexpr O o5{1}; // engaged
static_assert ( (o1 <= o1), "" );
static_assert ( (o1 <= o2), "" );
static_assert ( (o1 <= o3), "" );
static_assert ( (o1 <= o4), "" );
static_assert ( (o1 <= o5), "" );
static_assert ( (o2 <= o1), "" );
static_assert ( (o2 <= o2), "" );
static_assert ( (o2 <= o3), "" );
static_assert ( (o2 <= o4), "" );
static_assert ( (o2 <= o5), "" );
static_assert ( !(o3 <= o1), "" );
static_assert ( !(o3 <= o2), "" );
static_assert ( (o3 <= o3), "" );
static_assert ( (o3 <= o4), "" );
static_assert ( (o3 <= o5), "" );
static_assert ( !(o4 <= o1), "" );
static_assert ( !(o4 <= o2), "" );
static_assert ( !(o4 <= o3), "" );
static_assert ( (o4 <= o4), "" );
static_assert ( !(o4 <= o5), "" );
static_assert ( !(o5 <= o1), "" );
static_assert ( !(o5 <= o2), "" );
static_assert ( (o5 <= o3), "" );
static_assert ( (o5 <= o4), "" );
static_assert ( (o5 <= o5), "" );
}
#endif
}

16
libcxx/test/utilities/optional/optional.relops/less_than.pass.cpp
View File

@ -43,20 +43,20 @@ int main()
static_assert ( !(o1 < o1), "" );
static_assert ( !(o1 < o2), "" );
static_assert ( o1 < o3 , "" );
static_assert ( o1 < o4 , "" );
static_assert ( o1 < o5 , "" );
static_assert ( (o1 < o3), "" );
static_assert ( (o1 < o4), "" );
static_assert ( (o1 < o5), "" );
static_assert ( !(o2 < o1), "" );
static_assert ( !(o2 < o2), "" );
static_assert ( o2 < o3 , "" );
static_assert ( o2 < o4 , "" );
static_assert ( o2 < o5 , "" );
static_assert ( (o2 < o3), "" );
static_assert ( (o2 < o4), "" );
static_assert ( (o2 < o5), "" );
static_assert ( !(o3 < o1), "" );
static_assert ( !(o3 < o2), "" );
static_assert ( !(o3 < o3), "" );
static_assert ( o3 < o4 , "" );
static_assert ( (o3 < o4), "" );
static_assert ( !(o3 < o5), "" );
static_assert ( !(o4 < o1), "" );
@ -68,7 +68,7 @@ int main()
static_assert ( !(o5 < o1), "" );
static_assert ( !(o5 < o2), "" );
static_assert ( !(o5 < o3), "" );
static_assert ( o5 < o4 , "" );
static_assert ( (o5 < o4), "" );
static_assert ( !(o5 < o5), "" );
}
#endif

79
libcxx/test/utilities/optional/optional.relops/not_equal.pass.cpp Normal file
View File

@ -0,0 +1,79 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <optional>
// template <class T> constexpr bool operator!=(const optional<T>& x, const optional<T>& y);
#include <experimental/optional>
#include <type_traits>
#include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional;
struct X
{
int i_;
constexpr X(int i) : i_(i) {}
};
constexpr bool operator == ( const X &lhs, const X &rhs )
{ return lhs.i_ == rhs.i_ ; }
#endif
int main()
{
#if _LIBCPP_STD_VER > 11
{
typedef X T;
typedef optional<T> O;
constexpr O o1; // disengaged
constexpr O o2; // disengaged
constexpr O o3{1}; // engaged
constexpr O o4{2}; // engaged
constexpr O o5{1}; // engaged
static_assert ( !(o1 != o1), "" );
static_assert ( !(o1 != o2), "" );
static_assert ( (o1 != o3), "" );
static_assert ( (o1 != o4), "" );
static_assert ( (o1 != o5), "" );
static_assert ( !(o2 != o1), "" );
static_assert ( !(o2 != o2), "" );
static_assert ( (o2 != o3), "" );
static_assert ( (o2 != o4), "" );
static_assert ( (o2 != o5), "" );
static_assert ( (o3 != o1), "" );
static_assert ( (o3 != o2), "" );
static_assert ( !(o3 != o3), "" );
static_assert ( (o3 != o4), "" );
static_assert ( !(o3 != o5), "" );
static_assert ( (o4 != o1), "" );
static_assert ( (o4 != o2), "" );
static_assert ( (o4 != o3), "" );
static_assert ( !(o4 != o4), "" );
static_assert ( (o4 != o5), "" );
static_assert ( (o5 != o1), "" );
static_assert ( (o5 != o2), "" );
static_assert ( !(o5 != o3), "" );
static_assert ( (o5 != o4), "" );
static_assert ( !(o5 != o5), "" );
}
#endif
}