Author: ericwf
Date: Wed Oct 12 01:48:31 2016
New Revision: 283978
URL: http://llvm.org/viewvc/llvm-project?rev=283978&view=rev
Log:
Revert Add <optional>. Will recommit with better commit message
Removed:
libcxx/trunk/include/optional
libcxx/trunk/test/libcxx/utilities/optional/
libcxx/trunk/test/std/utilities/optional/
Modified:
libcxx/trunk/.gitignore
libcxx/trunk/include/__config
libcxx/trunk/include/type_traits
libcxx/trunk/src/optional.cpp
libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
libcxx/trunk/test/support/archetypes.hpp
libcxx/trunk/test/support/archetypes.ipp
Modified: libcxx/trunk/.gitignore
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/.gitignore?rev=283978&r1=283977&r2=283978&view=diff
==============================================================================
--- libcxx/trunk/.gitignore (original)
+++ libcxx/trunk/.gitignore Wed Oct 12 01:48:31 2016
@@ -56,6 +56,3 @@ target/
# MSVC libraries test harness
env.lst
keep.lst
-
-# Editor by-products
-.vscode/
Modified: libcxx/trunk/include/__config
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/__config?rev=283978&r1=283977&r2=283978&view=diff
==============================================================================
--- libcxx/trunk/include/__config (original)
+++ libcxx/trunk/include/__config Wed Oct 12 01:48:31 2016
@@ -914,10 +914,6 @@ extern "C" void __sanitizer_annotate_con
#define _LIBCPP_SAFE_STATIC
#endif
-#if !__has_builtin(__builtin_addressof) && _GNUC_VER < 700
-#define _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
-#endif
-
#endif // __cplusplus
#endif // _LIBCPP_CONFIG
Removed: libcxx/trunk/include/optional
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/optional?rev=283977&view=auto
==============================================================================
--- libcxx/trunk/include/optional (original)
+++ libcxx/trunk/include/optional (removed)
@@ -1,1318 +0,0 @@
-// -*- C++ -*-
-//===-------------------------- optional
----------------------------------===//
-//
-// 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.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_OPTIONAL
-#define _LIBCPP_OPTIONAL
-
-/*
- optional synopsis
-
-// C++1z
-
-namespace std {
- // 20.6.3, optional for object types
- template <class T> class optional;
-
- // 20.6.4, no-value state indicator
- struct nullopt_t{see below };
- constexpr nullopt_t nullopt(unspecified );
-
- // 20.6.5, class bad_optional_access
- class bad_optional_access;
-
- // 20.6.6, 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>&);
- 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;
-
- // 20.6.8, 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>&);
-
- // 20.6.9, specialized algorithms
- template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below
);
- template <class T> constexpr optional<see below > make_optional(T&&);
- template <class T, class... Args>
- constexpr optional<T> make_optional(Args&&... args);
- template <class T, class U, class... Args>
- constexpr optional<T> make_optional(initializer_list<U> il, Args&&...
args);
-
- // 20.6.10, hash support
- template <class T> struct hash;
- template <class T> struct hash<optional<T>>;
-
- template <class T> class optional {
- public:
- using value_type = T;
-
- // 20.6.3.1, constructors
- constexpr optional() noexcept;
- constexpr optional(nullopt_t) noexcept;
- optional(const optional &);
- optional(optional &&) noexcept(see below );
- 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 &&...);
- template <class U = T>
- constexpr EXPLICIT optional(U &&);
- template <class U>
- constexpr EXPLICIT optional(const optional<U> &);
- template <class U>
- constexpr EXPLICIT optional(optional<U> &&);
-
- // 20.6.3.2, destructor
- ~optional();
-
- // 20.6.3.3, assignment
- optional &operator=(nullopt_t) noexcept;
- optional &operator=(const optional &);
- optional &operator=(optional &&) noexcept(see below );
- template <class U = T> optional &operator=(U &&);
- template <class U> optional &operator=(const optional<U> &);
- template <class U> optional &operator=(optional<U> &&);
- template <class... Args> void emplace(Args &&...);
- template <class U, class... Args>
- void emplace(initializer_list<U>, Args &&...);
-
- // 20.6.3.4, swap
- void swap(optional &) noexcept(see below );
-
- // 20.6.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 bool has_value() 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 &&) &&;
-
- // 20.6.3.6, modifiers
- void reset() noexcept;
-
- private:
- T *val; // exposition only
- };
-} // namespace std
-
-*/
-
-#include <__config>
-#include <__debug>
-#include <__functional_base>
-#include <__undef_min_max>
-#include <functional>
-#include <initializer_list>
-#include <new>
-#include <stdexcept>
-#include <type_traits>
-#include <utility>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#pragma GCC system_header
-#endif
-
-namespace std // purposefully not using versioning namespace
-{
-
-class _LIBCPP_EXCEPTION_ABI bad_optional_access
- : public logic_error
-{
-public:
- _LIBCPP_INLINE_VISIBILITY
- bad_optional_access() : logic_error("bad optional access") {}
-
- // Get the key function ~bad_optional_access() into the dylib
- _LIBCPP_FUNC_VIS
- virtual ~bad_optional_access() _NOEXCEPT;
-};
-
-} // std
-
-#if _LIBCPP_STD_VER > 14
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-_LIBCPP_NORETURN
-inline _LIBCPP_INLINE_VISIBILITY
-void __throw_bad_optional_access() {
-#ifndef _LIBCPP_NO_EXCEPTIONS
- throw bad_optional_access();
-#else
- _VSTD::abort();
-#endif
-}
-
-struct nullopt_t
-{
- struct __secret_tag { _LIBCPP_INLINE_VISIBILITY explicit __secret_tag() =
default; };
- _LIBCPP_INLINE_VISIBILITY constexpr explicit nullopt_t(__secret_tag,
__secret_tag) noexcept {}
-};
-
-/* inline */ constexpr nullopt_t nullopt{nullopt_t::__secret_tag{},
nullopt_t::__secret_tag{}};
-
-template <class _Tp, bool = is_trivially_destructible<_Tp>::value>
-struct __optional_destruct_base;
-
-template <class _Tp>
-struct __optional_destruct_base<_Tp, false>
-{
- typedef _Tp value_type;
- static_assert(is_object_v<value_type>,
- "instantiation of optional with a non-object type is undefined
behavior");
- union
- {
- char __null_state_;
- value_type __val_;
- };
- bool __engaged_;
-
- _LIBCPP_INLINE_VISIBILITY
- ~__optional_destruct_base()
- {
- if (__engaged_)
- __val_.~value_type();
- }
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr __optional_destruct_base() noexcept
- : __null_state_(),
- __engaged_(false) {}
-
- template <class... _Args>
- _LIBCPP_INLINE_VISIBILITY
- constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
- : __val_(_VSTD::forward<_Args>(__args)...),
- __engaged_(true) {}
-
- _LIBCPP_INLINE_VISIBILITY
- void reset() noexcept
- {
- if (__engaged_)
- {
- __val_.~value_type();
- __engaged_ = false;
- }
- }
-};
-
-template <class _Tp>
-struct __optional_destruct_base<_Tp, true>
-{
- typedef _Tp value_type;
- static_assert(is_object_v<value_type>,
- "instantiation of optional with a non-object type is undefined
behavior");
- union
- {
- char __null_state_;
- value_type __val_;
- };
- bool __engaged_;
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr __optional_destruct_base() noexcept
- : __null_state_(),
- __engaged_(false) {}
-
- template <class... _Args>
- _LIBCPP_INLINE_VISIBILITY
- constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
- : __val_(_VSTD::forward<_Args>(__args)...),
- __engaged_(true) {}
-
- _LIBCPP_INLINE_VISIBILITY
- void reset() noexcept
- {
- if (__engaged_)
- {
- __engaged_ = false;
- }
- }
-};
-
-template <class _Tp, bool = is_reference<_Tp>::value>
-struct __optional_storage_base : __optional_destruct_base<_Tp>
-{
- using __base = __optional_destruct_base<_Tp>;
- using value_type = _Tp;
- using __base::__base;
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr bool has_value() const noexcept
- {
- return this->__engaged_;
- }
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr value_type& __get() & noexcept
- {
- return this->__val_;
- }
- _LIBCPP_INLINE_VISIBILITY
- constexpr const value_type& __get() const& noexcept
- {
- return this->__val_;
- }
- _LIBCPP_INLINE_VISIBILITY
- constexpr value_type&& __get() && noexcept
- {
- return _VSTD::move(this->__val_);
- }
- _LIBCPP_INLINE_VISIBILITY
- constexpr const value_type&& __get() const&& noexcept
- {
- return _VSTD::move(this->__val_);
- }
-
- template <class... _Args>
- _LIBCPP_INLINE_VISIBILITY
- void __construct(_Args&&... __args)
- {
- _LIBCPP_ASSERT(!has_value(), "__construct called for engaged
__optional_storage");
- ::new((void*)_VSTD::addressof(this->__val_))
value_type(_VSTD::forward<_Args>(__args)...);
- this->__engaged_ = true;
- }
-
- template <class _That>
- _LIBCPP_INLINE_VISIBILITY
- void __construct_from(_That&& __opt)
- {
- if (__opt.has_value())
- __construct(_VSTD::forward<_That>(__opt).__get());
- }
-
- template <class _That>
- _LIBCPP_INLINE_VISIBILITY
- void __assign_from(_That&& __opt)
- {
- if (this->__engaged_ == __opt.has_value())
- {
- if (this->__engaged_)
- this->__val_ = _VSTD::forward<_That>(__opt).__get();
- }
- else
- {
- if (this->__engaged_)
- this->reset();
- else
- __construct(_VSTD::forward<_That>(__opt).__get());
- }
- }
-};
-
-// optional<T&> is currently required ill-formed, however it may to be in the
-// future. For this reason it has already been implemented to ensure we can
-// make the change in an ABI compatible manner.
-template <class _Tp>
-struct __optional_storage_base<_Tp, true>
-{
- using value_type = _Tp;
- using __raw_type = remove_reference_t<_Tp>;
- __raw_type* __value_;
-
- template <class _Up>
- static constexpr bool __can_bind_reference() {
- using _RawUp = typename remove_reference<_Up>::type;
- using _UpPtr = _RawUp*;
- using _RawTp = typename remove_reference<_Tp>::type;
- using _TpPtr = _RawTp*;
- using _CheckLValueArg = integral_constant<bool,
- (is_lvalue_reference<_Up>::value && is_convertible<_UpPtr,
_TpPtr>::value)
- || is_same<_RawUp, reference_wrapper<_RawTp>>::value
- || is_same<_RawUp, reference_wrapper<typename
remove_const<_RawTp>::type>>::value
- >;
- return (is_lvalue_reference<_Tp>::value && _CheckLValueArg::value)
- || (is_rvalue_reference<_Tp>::value &&
!is_lvalue_reference<_Up>::value &&
- is_convertible<_UpPtr, _TpPtr>::value);
- }
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr __optional_storage_base() noexcept
- : __value_(nullptr) {}
-
- template <class _UArg>
- _LIBCPP_INLINE_VISIBILITY
- constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg)
- : __value_(_VSTD::addressof(__uarg))
- {
- static_assert(__can_bind_reference<_UArg>(),
- "Attempted to construct a reference element in tuple from a "
- "possible temporary");
- }
-
- _LIBCPP_INLINE_VISIBILITY
- void reset() noexcept { __value_ = nullptr; }
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr bool has_value() const noexcept
- { return __value_ != nullptr; }
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr value_type& __get() const& noexcept
- { return *__value_; }
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr value_type&& __get() const&& noexcept
- { return _VSTD::forward<value_type>(*__value_); }
-
- template <class _UArg>
- _LIBCPP_INLINE_VISIBILITY
- void __construct(_UArg&& __val)
- {
- _LIBCPP_ASSERT(!has_value(), "__construct called for engaged
__optional_storage");
- static_assert(__can_bind_reference<_UArg>(),
- "Attempted to construct a reference element in tuple from a "
- "possible temporary");
- __value_ = _VSTD::addressof(__val);
- }
-
- template <class _That>
- _LIBCPP_INLINE_VISIBILITY
- void __construct_from(_That&& __opt)
- {
- if (__opt.has_value())
- __construct(_VSTD::forward<_That>(__opt).__get());
- }
-
- template <class _That>
- _LIBCPP_INLINE_VISIBILITY
- void __assign_from(_That&& __opt)
- {
- if (has_value() == __opt.has_value())
- {
- if (has_value())
- *__value_ = _VSTD::forward<_That>(__opt).__get();
- }
- else
- {
- if (has_value())
- reset();
- else
- __construct(_VSTD::forward<_That>(__opt).__get());
- }
- }
-};
-
-template <class _Tp, bool = is_trivially_copyable<_Tp>::value>
-struct __optional_storage;
-
-template <class _Tp>
-struct __optional_storage<_Tp, true> : __optional_storage_base<_Tp>
-{
- using __optional_storage_base<_Tp>::__optional_storage_base;
-};
-
-template <class _Tp>
-struct __optional_storage<_Tp, false> : __optional_storage_base<_Tp>
-{
- using value_type = _Tp;
- using __optional_storage_base<_Tp>::__optional_storage_base;
-
- _LIBCPP_INLINE_VISIBILITY
- __optional_storage() = default;
-
- _LIBCPP_INLINE_VISIBILITY
- __optional_storage(const __optional_storage& __opt)
- {
- this->__construct_from(__opt);
- }
-
- _LIBCPP_INLINE_VISIBILITY
- __optional_storage(__optional_storage&& __opt)
- noexcept(is_nothrow_move_constructible_v<value_type>)
- {
- this->__construct_from(_VSTD::move(__opt));
- }
-
- _LIBCPP_INLINE_VISIBILITY
- __optional_storage& operator=(const __optional_storage& __opt)
- {
- this->__assign_from(__opt);
- return *this;
- }
-
- _LIBCPP_INLINE_VISIBILITY
- __optional_storage& operator=(__optional_storage&& __opt)
- noexcept(is_nothrow_move_assignable_v<value_type> &&
- is_nothrow_move_constructible_v<value_type>)
- {
- this->__assign_from(_VSTD::move(__opt));
- return *this;
- }
-};
-
-template <class _Tp>
-using __optional_sfinae_ctor_base_t = __sfinae_ctor_base<
- is_copy_constructible<_Tp>::value,
- is_move_constructible<_Tp>::value
->;
-
-template <class _Tp>
-using __optional_sfinae_assign_base_t = __sfinae_assign_base<
- (is_copy_constructible<_Tp>::value && is_copy_assignable<_Tp>::value),
- (is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value) ||
- (is_copy_constructible<_Tp>::value && is_copy_assignable<_Tp>::value)
->;
-
-template <class _Tp>
-class optional
- : private __optional_storage<_Tp>
- , private __optional_sfinae_ctor_base_t<_Tp>
- , private __optional_sfinae_assign_base_t<_Tp>
-{
- using __base = __optional_storage<_Tp>;
-public:
- using value_type = _Tp;
-
-private:
- // Disable the reference extension using this static assert.
- static_assert(!is_same_v<value_type, in_place_t>,
- "instantiation of optional with in_place_t is ill-formed");
- static_assert(!is_same_v<__uncvref_t<value_type>, nullopt_t>,
- "instantiation of optional with nullopt_t is ill-formed");
- static_assert(!is_reference_v<value_type>,
- "instantiation of optional with a reference type is ill-formed");
- static_assert(is_destructible_v<value_type>,
- "instantiation of optional with a non-destructible type is
ill-formed");
-
- // LWG2756: conditionally explicit conversion from _Up
- struct _CheckOptionalArgsConstructor {
- template <class _Up>
- static constexpr bool __enable_implicit() {
- return is_constructible_v<_Tp, _Up&&> &&
- is_convertible_v<_Up&&, _Tp>;
- }
-
- template <class _Up>
- static constexpr bool __enable_explicit() {
- return is_constructible_v<_Tp, _Up&&> &&
- !is_convertible_v<_Up&&, _Tp>;
- }
- };
- template <class _Up>
- using _CheckOptionalArgsCtor = conditional_t<
- !is_same_v<in_place_t, _Up> &&
- !is_same_v<decay_t<_Up>, optional>,
- _CheckOptionalArgsConstructor,
- __check_tuple_constructor_fail
- >;
- template <class _QualUp>
- struct _CheckOptionalLikeConstructor {
- template <class _Up, class _Opt = optional<_Up>>
- using __check_constructible_from_opt = __lazy_or<
- is_constructible<_Tp, _Opt&>,
- is_constructible<_Tp, _Opt const&>,
- is_constructible<_Tp, _Opt&&>,
- is_constructible<_Tp, _Opt const&&>,
- is_convertible<_Opt&, _Tp>,
- is_convertible<_Opt const&, _Tp>,
- is_convertible<_Opt&&, _Tp>,
- is_convertible<_Opt const&&, _Tp>
- >;
- template <class _Up, class _Opt = optional<_Up>>
- using __check_assignable_from_opt = __lazy_or<
- is_assignable<_Tp&, _Opt&>,
- is_assignable<_Tp&, _Opt const&>,
- is_assignable<_Tp&, _Opt&&>,
- is_assignable<_Tp&, _Opt const&&>
- >;
- template <class _Up, class _QUp = _QualUp>
- static constexpr bool __enable_implicit() {
- return is_convertible<_QUp, _Tp>::value &&
- !__check_constructible_from_opt<_Up>::value;
- }
- template <class _Up, class _QUp = _QualUp>
- static constexpr bool __enable_explicit() {
- return !is_convertible<_QUp, _Tp>::value &&
- !__check_constructible_from_opt<_Up>::value;
- }
- template <class _Up, class _QUp = _QualUp>
- static constexpr bool __enable_assign() {
- // Construction and assignability of _Qup to _Tp has already been
- // checked.
- return !__check_constructible_from_opt<_Up>::value &&
- !__check_assignable_from_opt<_Up>::value;
- }
- };
-
- template <class _Up, class _QualUp>
- using _CheckOptionalLikeCtor = conditional_t<
- __lazy_and<
- __lazy_not<is_same<_Up, _Tp>>,
- is_constructible<_Tp, _QualUp>
- >::value,
- _CheckOptionalLikeConstructor<_QualUp>,
- __check_tuple_constructor_fail
- >;
- template <class _Up, class _QualUp>
- using _CheckOptionalLikeAssign = conditional_t<
- __lazy_and<
- __lazy_not<is_same<_Up, _Tp>>,
- is_constructible<_Tp, _QualUp>,
- is_assignable<_Tp&, _QualUp>
- >::value,
- _CheckOptionalLikeConstructor<_QualUp>,
- __check_tuple_constructor_fail
- >;
-public:
-
- _LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {}
- _LIBCPP_INLINE_VISIBILITY optional(const optional&) = default;
- _LIBCPP_INLINE_VISIBILITY optional(optional&&) = default;
- _LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {}
-
- template <class... _Args, class = enable_if_t<
- is_constructible_v<value_type, _Args...>>
- >
- _LIBCPP_INLINE_VISIBILITY
- constexpr explicit optional(in_place_t, _Args&&... __args)
- : __base(in_place, _VSTD::forward<_Args>(__args)...) {}
-
- template <class _Up, class... _Args, class = enable_if_t<
- is_constructible_v<value_type, initializer_list<_Up>&, _Args...>>
- >
- _LIBCPP_INLINE_VISIBILITY
- constexpr explicit optional(in_place_t, initializer_list<_Up> __il,
_Args&&... __args)
- : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {}
-
- template <class _Up = value_type, enable_if_t<
- _CheckOptionalArgsCtor<_Up>::template __enable_implicit<_Up>()
- , int> = 0>
- _LIBCPP_INLINE_VISIBILITY
- constexpr optional(_Up&& __v)
- : __base(in_place, _VSTD::forward<_Up>(__v)) {}
-
- template <class _Up, enable_if_t<
- _CheckOptionalArgsCtor<_Up>::template __enable_explicit<_Up>()
- , int> = 0>
- _LIBCPP_INLINE_VISIBILITY
- constexpr explicit optional(_Up&& __v)
- : __base(in_place, _VSTD::forward<_Up>(__v)) {}
-
- // LWG2756: conditionally explicit conversion from const optional<_Up>&
- template <class _Up, enable_if_t<
- _CheckOptionalLikeCtor<_Up, _Up const&>::template
__enable_implicit<_Up>()
- , int> = 0>
- _LIBCPP_INLINE_VISIBILITY
- optional(const optional<_Up>& __v)
- {
- this->__construct_from(__v);
- }
- template <class _Up, enable_if_t<
- _CheckOptionalLikeCtor<_Up, _Up const&>::template
__enable_explicit<_Up>()
- , int> = 0>
- _LIBCPP_INLINE_VISIBILITY
- explicit optional(const optional<_Up>& __v)
- {
- this->__construct_from(__v);
- }
-
- // LWG2756: conditionally explicit conversion from optional<_Up>&&
- template <class _Up, enable_if_t<
- _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_implicit<_Up>()
- , int> = 0>
- _LIBCPP_INLINE_VISIBILITY
- optional(optional<_Up>&& __v)
- {
- this->__construct_from(_VSTD::move(__v));
- }
- template <class _Up, enable_if_t<
- _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_explicit<_Up>()
- , int> = 0>
- _LIBCPP_INLINE_VISIBILITY
- explicit optional(optional<_Up>&& __v)
- {
- this->__construct_from(_VSTD::move(__v));
- }
-
- _LIBCPP_INLINE_VISIBILITY
- optional& operator=(nullopt_t) noexcept
- {
- reset();
- return *this;
- }
-
- _LIBCPP_INLINE_VISIBILITY optional& operator=(const optional&) = default;
- _LIBCPP_INLINE_VISIBILITY optional& operator=(optional&&) = default;
-
- // LWG2756
- template <class _Up = value_type,
- class = enable_if_t
- <
- !is_same_v<_Up, optional> &&
- !(is_same_v<_Up, value_type> &&
is_scalar_v<value_type>) &&
- is_constructible_v<value_type, _Up> &&
- is_assignable_v<value_type&, _Up>
- >
- >
- _LIBCPP_INLINE_VISIBILITY
- optional&
- operator=(_Up&& __v)
- {
- if (this->has_value())
- this->__get() = _VSTD::forward<_Up>(__v);
- else
- this->__construct(_VSTD::forward<_Up>(__v));
- return *this;
- }
-
- // LWG2756
- template <class _Up, enable_if_t<
- _CheckOptionalLikeAssign<_Up, _Up const&>::template
__enable_assign<_Up>()
- , int> = 0>
- _LIBCPP_INLINE_VISIBILITY
- optional&
- operator=(const optional<_Up>& __v)
- {
- this->__assign_from(__v);
- return *this;
- }
-
- // LWG2756
- template <class _Up, enable_if_t<
- _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_assign<_Up>()
- , int> = 0>
- _LIBCPP_INLINE_VISIBILITY
- optional&
- operator=(optional<_Up>&& __v)
- {
- this->__assign_from(_VSTD::move(__v));
- return *this;
- }
-
- template <class... _Args,
- class = enable_if_t
- <
- is_constructible_v<value_type, _Args...>
- >
- >
- _LIBCPP_INLINE_VISIBILITY
- void
- emplace(_Args&&... __args)
- {
- reset();
- this->__construct(_VSTD::forward<_Args>(__args)...);
- }
-
- template <class _Up, class... _Args,
- class = enable_if_t
- <
- is_constructible_v<value_type,
initializer_list<_Up>&, _Args...>
- >
- >
- _LIBCPP_INLINE_VISIBILITY
- void
- emplace(initializer_list<_Up> __il, _Args&&... __args)
- {
- reset();
- this->__construct(__il, _VSTD::forward<_Args>(__args)...);
- }
-
- template <bool _Dummy = false, class = enable_if_t<
- __dependent_type<is_move_constructible<_Tp>, _Dummy>::value &&
- __dependent_type<is_swappable<_Tp>, _Dummy>::value
- >>
- _LIBCPP_INLINE_VISIBILITY
- void swap(optional& __opt)
- noexcept(is_nothrow_move_constructible_v<value_type> &&
- is_nothrow_swappable_v<value_type>)
- {
- if (this->has_value() == __opt.has_value())
- {
- using _VSTD::swap;
- if (this->has_value())
- swap(this->__get(), __opt.__get());
- }
- else
- {
- if (this->has_value())
- {
- __opt.__construct(_VSTD::move(this->__get()));
- reset();
- }
- else
- {
- this->__construct(_VSTD::move(__opt.__get()));
- __opt.reset();
- }
- }
- }
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr
- add_pointer_t<value_type const>
- operator->() const
- {
- _LIBCPP_ASSERT(this->has_value(), "optional operator-> called for
disengaged value");
-#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
- return _VSTD::addressof(this->__get());
-#else
- return __operator_arrow(__has_operator_addressof<value_type>{},
this->__get());
-#endif
- }
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr
- add_pointer_t<value_type>
- operator->()
- {
- _LIBCPP_ASSERT(this->has_value(), "optional operator-> called for
disengaged value");
-#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
- return _VSTD::addressof(this->__get());
-#else
- return __operator_arrow(__has_operator_addressof<value_type>{},
this->__get());
-#endif
- }
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr
- const value_type&
- operator*() const&
- {
- _LIBCPP_ASSERT(this->has_value(), "optional operator* called for
disengaged value");
- return this->__get();
- }
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr
- value_type&
- operator*() &
- {
- _LIBCPP_ASSERT(this->has_value(), "optional operator* called for
disengaged value");
- return this->__get();
- }
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr
- value_type&&
- operator*() &&
- {
- _LIBCPP_ASSERT(this->has_value(), "optional operator* called for
disengaged value");
- return _VSTD::move(this->__get());
- }
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr
- const value_type&&
- operator*() const&&
- {
- _LIBCPP_ASSERT(this->has_value(), "optional operator* called for
disengaged value");
- return _VSTD::move(this->__get());
- }
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr explicit operator bool() const noexcept { return has_value(); }
-
- using __base::has_value;
- using __base::__get;
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr value_type const& value() const&
- {
- if (!this->has_value())
- __throw_bad_optional_access();
- return this->__get();
- }
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr value_type& value() &
- {
- if (!this->has_value())
- __throw_bad_optional_access();
- return this->__get();
- }
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr value_type&& value() &&
- {
- if (!this->has_value())
- __throw_bad_optional_access();
- return _VSTD::move(this->__get());
- }
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr value_type const&& value() const&&
- {
- if (!this->has_value())
- __throw_bad_optional_access();
- return _VSTD::move(this->__get());
- }
-
- template <class _Up>
- _LIBCPP_INLINE_VISIBILITY
- constexpr value_type value_or(_Up&& __v) const&
- {
- static_assert(is_copy_constructible_v<value_type>,
- "optional<T>::value_or: T must be copy constructible");
- static_assert(is_convertible_v<_Up, value_type>,
- "optional<T>::value_or: U must be convertible to T");
- return this->has_value() ? this->__get() :
-
static_cast<value_type>(_VSTD::forward<_Up>(__v));
- }
-
- template <class _Up>
- _LIBCPP_INLINE_VISIBILITY
- value_type value_or(_Up&& __v) &&
- {
- static_assert(is_move_constructible_v<value_type>,
- "optional<T>::value_or: T must be move constructible");
- static_assert(is_convertible_v<_Up, value_type>,
- "optional<T>::value_or: U must be convertible to T");
- return this->has_value() ? _VSTD::move(this->__get()) :
-
static_cast<value_type>(_VSTD::forward<_Up>(__v));
- }
-
- using __base::reset;
-
-private:
- template <class _Up>
- _LIBCPP_INLINE_VISIBILITY
- static _Up*
- __operator_arrow(true_type, _Up& __x)
- {
- return _VSTD::addressof(__x);
- }
-
- template <class _Up>
- _LIBCPP_INLINE_VISIBILITY
- static constexpr _Up*
- __operator_arrow(false_type, _Up& __x)
- {
- return &__x;
- }
-};
-
-// Comparisons between optionals
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
- is_convertible_v<decltype(_VSTD::declval<const _Tp&>() ==
- _VSTD::declval<const _Tp&>()), bool>,
- bool
->
-operator==(const optional<_Tp>& __x, const optional<_Tp>& __y)
-{
- if (static_cast<bool>(__x) != static_cast<bool>(__y))
- return false;
- if (!static_cast<bool>(__x))
- return true;
- return *__x == *__y;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
- is_convertible_v<decltype(_VSTD::declval<const _Tp&>() !=
- _VSTD::declval<const _Tp&>()), bool>,
- bool
->
-operator!=(const optional<_Tp>& __x, const optional<_Tp>& __y)
-{
- if (static_cast<bool>(__x) != static_cast<bool>(__y))
- return true;
- if (!static_cast<bool>(__x))
- return false;
- return *__x != *__y;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
- is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <
- _VSTD::declval<const _Tp&>()), bool>,
- bool
->
-operator<(const optional<_Tp>& __x, const optional<_Tp>& __y)
-{
- if (!static_cast<bool>(__y))
- return false;
- if (!static_cast<bool>(__x))
- return true;
- return *__x < *__y;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
- is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >
- _VSTD::declval<const _Tp&>()), bool>,
- bool
->
-operator>(const optional<_Tp>& __x, const optional<_Tp>& __y)
-{
- if (!static_cast<bool>(__x))
- return false;
- if (!static_cast<bool>(__y))
- return true;
- return *__x > *__y;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
- is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <=
- _VSTD::declval<const _Tp&>()), bool>,
- bool
->
-operator<=(const optional<_Tp>& __x, const optional<_Tp>& __y)
-{
- if (!static_cast<bool>(__x))
- return true;
- if (!static_cast<bool>(__y))
- return false;
- return *__x <= *__y;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
- is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >=
- _VSTD::declval<const _Tp&>()), bool>,
- bool
->
-operator>=(const optional<_Tp>& __x, const optional<_Tp>& __y)
-{
- if (!static_cast<bool>(__y))
- return true;
- if (!static_cast<bool>(__x))
- return false;
- return *__x >= *__y;
-}
-
-// Comparisons with nullopt
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator==(const optional<_Tp>& __x, nullopt_t) noexcept
-{
- return !static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator==(nullopt_t, const optional<_Tp>& __x) noexcept
-{
- return !static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator!=(const optional<_Tp>& __x, nullopt_t) noexcept
-{
- return static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator!=(nullopt_t, const optional<_Tp>& __x) noexcept
-{
- return static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator<(const optional<_Tp>&, nullopt_t) noexcept
-{
- return false;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator<(nullopt_t, const optional<_Tp>& __x) noexcept
-{
- return static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator<=(const optional<_Tp>& __x, nullopt_t) noexcept
-{
- return !static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator<=(nullopt_t, const optional<_Tp>& __x) noexcept
-{
- return true;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator>(const optional<_Tp>& __x, nullopt_t) noexcept
-{
- return static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator>(nullopt_t, const optional<_Tp>& __x) noexcept
-{
- return false;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator>=(const optional<_Tp>&, nullopt_t) noexcept
-{
- return true;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator>=(nullopt_t, const optional<_Tp>& __x) noexcept
-{
- return !static_cast<bool>(__x);
-}
-
-// Comparisons with T
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
- is_convertible_v<decltype(_VSTD::declval<const _Tp&>() ==
- _VSTD::declval<const _Tp&>()), bool>,
- bool
->
-operator==(const optional<_Tp>& __x, const _Tp& __v)
-{
- return static_cast<bool>(__x) ? *__x == __v : false;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
- is_convertible_v<decltype(_VSTD::declval<const _Tp&>() ==
- _VSTD::declval<const _Tp&>()), bool>,
- bool
->
-operator==(const _Tp& __v, const optional<_Tp>& __x)
-{
- return static_cast<bool>(__x) ? __v == *__x : false;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
- is_convertible_v<decltype(_VSTD::declval<const _Tp&>() !=
- _VSTD::declval<const _Tp&>()), bool>,
- bool
->
-operator!=(const optional<_Tp>& __x, const _Tp& __v)
-{
- return static_cast<bool>(__x) ? *__x != __v : true;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
- is_convertible_v<decltype(_VSTD::declval<const _Tp&>() !=
- _VSTD::declval<const _Tp&>()), bool>,
- bool
->
-operator!=(const _Tp& __v, const optional<_Tp>& __x)
-{
- return static_cast<bool>(__x) ? __v != *__x : true;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
- is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <
- _VSTD::declval<const _Tp&>()), bool>,
- bool
->
-operator<(const optional<_Tp>& __x, const _Tp& __v)
-{
- return static_cast<bool>(__x) ? *__x < __v : true;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
- is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <
- _VSTD::declval<const _Tp&>()), bool>,
- bool
->
-operator<(const _Tp& __v, const optional<_Tp>& __x)
-{
- return static_cast<bool>(__x) ? __v < *__x : false;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
- is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <=
- _VSTD::declval<const _Tp&>()), bool>,
- bool
->
-operator<=(const optional<_Tp>& __x, const _Tp& __v)
-{
- return static_cast<bool>(__x) ? *__x <= __v : true;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
- is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <=
- _VSTD::declval<const _Tp&>()), bool>,
- bool
->
-operator<=(const _Tp& __v, const optional<_Tp>& __x)
-{
- return static_cast<bool>(__x) ? __v <= *__x : false;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
- is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >
- _VSTD::declval<const _Tp&>()), bool>,
- bool
->
-operator>(const optional<_Tp>& __x, const _Tp& __v)
-{
- return static_cast<bool>(__x) ? *__x > __v : false;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
- is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >
- _VSTD::declval<const _Tp&>()), bool>,
- bool
->
-operator>(const _Tp& __v, const optional<_Tp>& __x)
-{
- return static_cast<bool>(__x) ? __v > *__x : true;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
- is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >=
- _VSTD::declval<const _Tp&>()), bool>,
- bool
->
-operator>=(const optional<_Tp>& __x, const _Tp& __v)
-{
- return static_cast<bool>(__x) ? *__x >= __v : false;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
- is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >=
- _VSTD::declval<const _Tp&>()), bool>,
- bool
->
-operator>=(const _Tp& __v, const optional<_Tp>& __x)
-{
- return static_cast<bool>(__x) ? __v >= *__x : true;
-}
-
-
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-enable_if_t<
- is_move_constructible_v<_Tp> && is_swappable_v<_Tp>,
- void
->
-swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y)))
-{
- __x.swap(__y);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-optional<decay_t<_Tp>> make_optional(_Tp&& __v)
-{
- return optional<decay_t<_Tp>>(_VSTD::forward<_Tp>(__v));
-}
-
-template <class _Tp, class... _Args>
-_LIBCPP_INLINE_VISIBILITY constexpr
-optional<_Tp> make_optional(_Args&&... __args)
-{
- return optional<_Tp>(in_place, _VSTD::forward<_Args>(__args)...);
-}
-
-template <class _Tp, class _Up, class... _Args>
-_LIBCPP_INLINE_VISIBILITY constexpr
-optional<_Tp> make_optional(initializer_list<_Up> __il, _Args&&... __args)
-{
- return optional<_Tp>(in_place, __il, _VSTD::forward<_Args>(__args)...);
-}
-
-template <class _Tp>
-struct _LIBCPP_TYPE_VIS_ONLY hash<optional<_Tp> >
-{
- typedef optional<_Tp> argument_type;
- typedef size_t result_type;
-
- _LIBCPP_INLINE_VISIBILITY
- result_type operator()(const argument_type& __opt) const _NOEXCEPT
- {
- return static_cast<bool>(__opt) ? hash<_Tp>()(*__opt) : 0;
- }
-};
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP_STD_VER > 14
-
-#endif // _LIBCPP_OPTIONAL
Modified: libcxx/trunk/include/type_traits
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/type_traits?rev=283978&r1=283977&r2=283978&view=diff
==============================================================================
--- libcxx/trunk/include/type_traits (original)
+++ libcxx/trunk/include/type_traits Wed Oct 12 01:48:31 2016
@@ -425,7 +425,7 @@ template <bool _Bp, class _Tp = void> us
#endif
// addressof
-#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
+#if __has_builtin(__builtin_addressof) || _GNUC_VER >= 700
template <class _Tp>
inline _LIBCPP_CONSTEXPR_AFTER_CXX14
@@ -446,7 +446,7 @@ addressof(_Tp& __x) _NOEXCEPT
return (_Tp*)&reinterpret_cast<const volatile char&>(__x);
}
-#endif // _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
+#endif // __has_builtin(__builtin_addressof)
#if defined(_LIBCPP_HAS_OBJC_ARC) &&
!defined(_LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF)
// Objective-C++ Automatic Reference Counting uses qualified pointers
Modified: libcxx/trunk/src/optional.cpp
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/src/optional.cpp?rev=283978&r1=283977&r2=283978&view=diff
==============================================================================
--- libcxx/trunk/src/optional.cpp (original)
+++ libcxx/trunk/src/optional.cpp Wed Oct 12 01:48:31 2016
@@ -7,18 +7,18 @@
//
//===----------------------------------------------------------------------===//
-#include "optional"
#include "experimental/optional"
-namespace std
-{
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
-bad_optional_access::~bad_optional_access() _NOEXCEPT = default;
+#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
-} // std
+bad_optional_access::~bad_optional_access() _NOEXCEPT {}
-_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
+#else
bad_optional_access::~bad_optional_access() _NOEXCEPT = default;
+#endif
+
_LIBCPP_END_NAMESPACE_EXPERIMENTAL
Modified:
libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp?rev=283978&r1=283977&r2=283978&view=diff
==============================================================================
---
libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
(original)
+++
libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_swappable_with.pass.cpp
Wed Oct 12 01:48:31 2016
@@ -59,7 +59,7 @@ int main()
!std::is_nothrow_swappable_with<A&, A&>::value, "");
}
{
- // test that heterogeneous swap is allowed only if both 'swap(A, B)'
and
+ // test that hetrogenius swap is allowed only if both 'swap(A, B)' and
// 'swap(B, A)' are valid.
static_assert(std::is_nothrow_swappable_with<A&, B&>::value, "");
static_assert(!std::is_nothrow_swappable_with<A&, C&>::value &&
Modified: libcxx/trunk/test/support/archetypes.hpp
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/support/archetypes.hpp?rev=283978&r1=283977&r2=283978&view=diff
==============================================================================
--- libcxx/trunk/test/support/archetypes.hpp (original)
+++ libcxx/trunk/test/support/archetypes.hpp Wed Oct 12 01:48:31 2016
@@ -1,186 +1,10 @@
#ifndef TEST_SUPPORT_ARCHETYPES_HPP
#define TEST_SUPPORT_ARCHETYPES_HPP
-#include <type_traits>
-#include <cassert>
-
#include "test_macros.h"
#if TEST_STD_VER >= 11
-namespace ArchetypeBases {
-
-template <bool, class T>
-struct DepType : T {};
-
-struct NullBase {};
-
-template <class Derived, bool Explicit = false>
-struct TestBase {
- static int alive;
- static int constructed;
- static int value_constructed;
- static int default_constructed;
- static int copy_constructed;
- static int move_constructed;
- static int assigned;
- static int value_assigned;
- static int copy_assigned;
- static int move_assigned;
- static int destroyed;
-
- static void reset() {
- assert(alive == 0);
- alive = 0;
- reset_constructors();
- }
-
- static void reset_constructors() {
- constructed = value_constructed = default_constructed =
- copy_constructed = move_constructed = 0;
- assigned = value_assigned = copy_assigned = move_assigned = destroyed =
0;
- }
-
- TestBase() noexcept : value(0) {
- ++alive; ++constructed; ++default_constructed;
- }
- template <bool Dummy = true, typename std::enable_if<Dummy && Explicit,
bool>::type = true>
- explicit TestBase(int x) noexcept : value(x) {
- ++alive; ++constructed; ++value_constructed;
- }
- template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit,
bool>::type = true>
- TestBase(int x) noexcept : value(x) {
- ++alive; ++constructed; ++value_constructed;
- }
- template <bool Dummy = true, typename std::enable_if<Dummy && Explicit,
bool>::type = true>
- explicit TestBase(int x, int y) noexcept : value(y) {
- ++alive; ++constructed; ++value_constructed;
- }
- template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit,
bool>::type = true>
- TestBase(int x, int y) noexcept : value(y) {
- ++alive; ++constructed; ++value_constructed;
- }
- template <bool Dummy = true, typename std::enable_if<Dummy && Explicit,
bool>::type = true>
- explicit TestBase(std::initializer_list<int>& il, int y = 0) noexcept
- : value(il.size()) {
- ++alive; ++constructed; ++value_constructed;
- }
- template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit,
bool>::type = true>
- TestBase(std::initializer_list<int>& il, int y = 0) noexcept :
value(il.size()) {
- ++alive; ++constructed; ++value_constructed;
- }
- TestBase& operator=(int xvalue) noexcept {
- value = xvalue;
- ++assigned; ++value_assigned;
- return *this;
- }
-protected:
- ~TestBase() {
- assert(value != -999); assert(alive > 0);
- --alive; ++destroyed; value = -999;
- }
- TestBase(TestBase const& o) noexcept : value(o.value) {
- assert(o.value != -1); assert(o.value != -999);
- ++alive; ++constructed; ++copy_constructed;
- }
- TestBase(TestBase && o) noexcept : value(o.value) {
- assert(o.value != -1); assert(o.value != -999);
- ++alive; ++constructed; ++move_constructed;
- o.value = -1;
- }
- TestBase& operator=(TestBase const& o) noexcept {
- assert(o.value != -1); assert(o.value != -999);
- ++assigned; ++copy_assigned;
- value = o.value;
- return *this;
- }
- TestBase& operator=(TestBase&& o) noexcept {
- assert(o.value != -1); assert(o.value != -999);
- ++assigned; ++move_assigned;
- value = o.value;
- o.value = -1;
- return *this;
- }
-public:
- int value;
-};
-
-template <class D, bool E> int TestBase<D, E>::alive = 0;
-template <class D, bool E> int TestBase<D, E>::constructed = 0;
-template <class D, bool E> int TestBase<D, E>::value_constructed = 0;
-template <class D, bool E> int TestBase<D, E>::default_constructed = 0;
-template <class D, bool E> int TestBase<D, E>::copy_constructed = 0;
-template <class D, bool E> int TestBase<D, E>::move_constructed = 0;
-template <class D, bool E> int TestBase<D, E>::assigned = 0;
-template <class D, bool E> int TestBase<D, E>::value_assigned = 0;
-template <class D, bool E> int TestBase<D, E>::copy_assigned = 0;
-template <class D, bool E> int TestBase<D, E>::move_assigned = 0;
-template <class D, bool E> int TestBase<D, E>::destroyed = 0;
-
-template <bool Explicit = false>
-struct ValueBase {
- template <bool Dummy = true, typename std::enable_if<Dummy && Explicit,
bool>::type = true>
- explicit constexpr ValueBase(int x) : value(x) {}
- template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit,
bool>::type = true>
- constexpr ValueBase(int x) : value(x) {}
- template <bool Dummy = true, typename std::enable_if<Dummy && Explicit,
bool>::type = true>
- explicit constexpr ValueBase(int x, int y) : value(y) {}
- template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit,
bool>::type = true>
- constexpr ValueBase(int x, int y) : value(y) {}
- template <bool Dummy = true, typename std::enable_if<Dummy && Explicit,
bool>::type = true>
- explicit constexpr ValueBase(std::initializer_list<int>& il, int y = 0) :
value(il.size()) {}
- template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit,
bool>::type = true>
- constexpr ValueBase(std::initializer_list<int>& il, int y = 0) :
value(il.size()) {}
- constexpr ValueBase& operator=(int xvalue) noexcept {
- value = xvalue;
- return *this;
- }
- //~ValueBase() { assert(value != -999); value = -999; }
- int value;
-protected:
- constexpr ValueBase() noexcept : value(0) {}
- constexpr ValueBase(ValueBase const& o) noexcept : value(o.value) {
- assert(o.value != -1); assert(o.value != -999);
- }
- constexpr ValueBase(ValueBase && o) noexcept : value(o.value) {
- assert(o.value != -1); assert(o.value != -999);
- o.value = -1;
- }
- constexpr ValueBase& operator=(ValueBase const& o) noexcept {
- assert(o.value != -1); assert(o.value != -999);
- value = o.value;
- return *this;
- }
- constexpr ValueBase& operator=(ValueBase&& o) noexcept {
- assert(o.value != -1); assert(o.value != -999);
- value = o.value;
- o.value = -1;
- return *this;
- }
-};
-
-
-template <bool Explicit = false>
-struct TrivialValueBase {
- template <bool Dummy = true, typename std::enable_if<Dummy && Explicit,
bool>::type = true>
- explicit constexpr TrivialValueBase(int x) : value(x) {}
- template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit,
bool>::type = true>
- constexpr TrivialValueBase(int x) : value(x) {}
- template <bool Dummy = true, typename std::enable_if<Dummy && Explicit,
bool>::type = true>
- explicit constexpr TrivialValueBase(int x, int y) : value(y) {}
- template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit,
bool>::type = true>
- constexpr TrivialValueBase(int x, int y) : value(y) {}
- template <bool Dummy = true, typename std::enable_if<Dummy && Explicit,
bool>::type = true>
- explicit constexpr TrivialValueBase(std::initializer_list<int>& il, int y
= 0) : value(il.size()) {}
- template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit,
bool>::type = true>
- constexpr TrivialValueBase(std::initializer_list<int>& il, int y = 0) :
value(il.size()) {};
- int value;
-protected:
- constexpr TrivialValueBase() noexcept : value(0) {}
-};
-
-}
-
//============================================================================//
// Trivial Implicit Test Types
namespace ImplicitTypes {
@@ -194,18 +18,9 @@ namespace ExplicitTypes {
#include "archetypes.ipp"
}
-
-//============================================================================//
-//
-namespace NonConstexprTypes {
-#define DEFINE_CONSTEXPR
-#include "archetypes.ipp"
-}
-
//============================================================================//
-// Non-literal implicit test types
+// Non-Trivial Implicit Test Types
namespace NonLiteralTypes {
-#define DEFINE_ASSIGN_CONSTEXPR
#define DEFINE_DTOR(Name) ~Name() {}
#include "archetypes.ipp"
}
@@ -214,144 +29,9 @@ namespace NonLiteralTypes {
// Non-Trivially Copyable Implicit Test Types
namespace NonTrivialTypes {
#define DEFINE_CTOR {}
-#define DEFINE_ASSIGN { return *this; }
-#define DEFINE_DEFAULT_CTOR = default
-#include "archetypes.ipp"
-}
-
-//============================================================================//
-// Implicit counting types
-namespace TestTypes {
-#define DEFINE_CONSTEXPR
-#define DEFINE_BASE(Name) ::ArchetypeBases::TestBase<Name>
-#include "archetypes.ipp"
-
-using TestType = AllCtors;
-
-// Add equality operators
-template <class Tp>
-constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
- return L.value == R.value;
-}
-
-template <class Tp>
-constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
- return L.value != R.value;
-}
-
-}
-
-//============================================================================//
-// Implicit counting types
-namespace ExplicitTestTypes {
-#define DEFINE_CONSTEXPR
-#define DEFINE_EXPLICIT explicit
-#define DEFINE_BASE(Name) ::ArchetypeBases::TestBase<Name, true>
-#include "archetypes.ipp"
-
-using TestType = AllCtors;
-
-// Add equality operators
-template <class Tp>
-constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
- return L.value == R.value;
-}
-
-template <class Tp>
-constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
- return L.value != R.value;
-}
-
-}
-
-//============================================================================//
-// Implicit value types
-namespace ConstexprTestTypes {
-#define DEFINE_BASE(Name) ::ArchetypeBases::ValueBase<>
-#include "archetypes.ipp"
-
-using TestType = AllCtors;
-
-// Add equality operators
-template <class Tp>
-constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
- return L.value == R.value;
-}
-
-template <class Tp>
-constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
- return L.value != R.value;
-}
-
-} // end namespace ValueTypes
-
-
-//============================================================================//
-//
-namespace ExplicitConstexprTestTypes {
-#define DEFINE_EXPLICIT explicit
-#define DEFINE_BASE(Name) ::ArchetypeBases::ValueBase<true>
-#include "archetypes.ipp"
-
-using TestType = AllCtors;
-
-// Add equality operators
-template <class Tp>
-constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
- return L.value == R.value;
-}
-
-template <class Tp>
-constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
- return L.value != R.value;
-}
-
-} // end namespace ValueTypes
-
-
-//============================================================================//
-//
-namespace TrivialTestTypes {
-#define DEFINE_BASE(Name) ::ArchetypeBases::TrivialValueBase<false>
-#include "archetypes.ipp"
-
-using TestType = AllCtors;
-
-// Add equality operators
-template <class Tp>
-constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
- return L.value == R.value;
-}
-
-template <class Tp>
-constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
- return L.value != R.value;
-}
-
-} // end namespace TrivialValueTypes
-
-//============================================================================//
-//
-namespace ExplicitTrivialTestTypes {
-#define DEFINE_EXPLICIT explicit
-#define DEFINE_BASE(Name) ::ArchetypeBases::TrivialValueBase<true>
#include "archetypes.ipp"
-
-using TestType = AllCtors;
-
-// Add equality operators
-template <class Tp>
-constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
- return L.value == R.value;
}
-template <class Tp>
-constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
- return L.value != R.value;
-}
-
-} // end namespace ExplicitTrivialTestTypes
-
#endif // TEST_STD_VER >= 11
#endif // TEST_SUPPORT_ARCHETYPES_HPP
Modified: libcxx/trunk/test/support/archetypes.ipp
URL:
http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/support/archetypes.ipp?rev=283978&r1=283977&r2=283978&view=diff
==============================================================================
--- libcxx/trunk/test/support/archetypes.ipp (original)
+++ libcxx/trunk/test/support/archetypes.ipp Wed Oct 12 01:48:31 2016
@@ -1,22 +1,10 @@
-#ifndef DEFINE_BASE
-#define DEFINE_BASE(Name) ::ArchetypeBases::NullBase
-#endif
#ifndef DEFINE_EXPLICIT
#define DEFINE_EXPLICIT
#endif
-#ifndef DEFINE_CONSTEXPR
-#define DEFINE_CONSTEXPR constexpr
-#endif
-#ifndef DEFINE_ASSIGN_CONSTEXPR
-#define DEFINE_ASSIGN_CONSTEXPR DEFINE_CONSTEXPR
-#endif
#ifndef DEFINE_CTOR
#define DEFINE_CTOR = default
#endif
-#ifndef DEFINE_DEFAULT_CTOR
-#define DEFINE_DEFAULT_CTOR DEFINE_CTOR
-#endif
#ifndef DEFINE_ASSIGN
#define DEFINE_ASSIGN = default
#endif
@@ -24,117 +12,78 @@
#define DEFINE_DTOR(Name)
#endif
-struct AllCtors : DEFINE_BASE(AllCtors) {
- using Base = DEFINE_BASE(AllCtors);
- using Base::Base;
- using Base::operator=;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR AllCtors() DEFINE_DEFAULT_CTOR;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR AllCtors(AllCtors const&) DEFINE_CTOR;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR AllCtors(AllCtors &&) DEFINE_CTOR;
- DEFINE_ASSIGN_CONSTEXPR AllCtors& operator=(AllCtors const&) DEFINE_ASSIGN;
- DEFINE_ASSIGN_CONSTEXPR AllCtors& operator=(AllCtors &&) DEFINE_ASSIGN;
- DEFINE_DTOR(AllCtors)
-};
-
-struct NoCtors : DEFINE_BASE(NoCtors) {
- using Base = DEFINE_BASE(NoCtors);
- using Base::Base;
- DEFINE_EXPLICIT NoCtors() = delete;
- DEFINE_EXPLICIT NoCtors(NoCtors const&) = delete;
- NoCtors& operator=(NoCtors const&) = delete;
- DEFINE_DTOR(NoCtors)
-};
-
-struct NoDefault : DEFINE_BASE(NoDefault) {
- using Base = DEFINE_BASE(NoDefault);
- using Base::Base;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR NoDefault() = delete;
+struct NoDefault {
+ DEFINE_EXPLICIT NoDefault() = delete;
DEFINE_DTOR(NoDefault)
};
-struct DefaultOnly : DEFINE_BASE(DefaultOnly) {
- using Base = DEFINE_BASE(DefaultOnly);
- using Base::Base;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR DefaultOnly() DEFINE_DEFAULT_CTOR;
- DefaultOnly(DefaultOnly const&) = delete;
- DefaultOnly& operator=(DefaultOnly const&) = delete;
- DEFINE_DTOR(DefaultOnly)
+struct AllCtors {
+ DEFINE_EXPLICIT AllCtors() DEFINE_CTOR;
+ DEFINE_EXPLICIT AllCtors(AllCtors const&) DEFINE_CTOR;
+ DEFINE_EXPLICIT AllCtors(AllCtors &&) DEFINE_CTOR;
+ AllCtors& operator=(AllCtors const&) DEFINE_ASSIGN;
+ AllCtors& operator=(AllCtors &&) DEFINE_ASSIGN;
+ DEFINE_DTOR(AllCtors)
};
-struct Copyable : DEFINE_BASE(Copyable) {
- using Base = DEFINE_BASE(Copyable);
- using Base::Base;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR Copyable() DEFINE_DEFAULT_CTOR;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR Copyable(Copyable const &) DEFINE_CTOR;
+struct Copyable {
+ DEFINE_EXPLICIT Copyable() DEFINE_CTOR;
+ DEFINE_EXPLICIT Copyable(Copyable const &) DEFINE_CTOR;
Copyable &operator=(Copyable const &) DEFINE_ASSIGN;
DEFINE_DTOR(Copyable)
};
-struct CopyOnly : DEFINE_BASE(CopyOnly) {
- using Base = DEFINE_BASE(CopyOnly);
- using Base::Base;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyOnly() DEFINE_DEFAULT_CTOR;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyOnly(CopyOnly const &) DEFINE_CTOR;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyOnly(CopyOnly &&) = delete;
+struct CopyOnly {
+ DEFINE_EXPLICIT CopyOnly() DEFINE_CTOR;
+ DEFINE_EXPLICIT CopyOnly(CopyOnly const &) DEFINE_CTOR;
+ DEFINE_EXPLICIT CopyOnly(CopyOnly &&) = delete;
CopyOnly &operator=(CopyOnly const &) DEFINE_ASSIGN;
CopyOnly &operator=(CopyOnly &&) = delete;
DEFINE_DTOR(CopyOnly)
};
-struct NonCopyable : DEFINE_BASE(NonCopyable) {
- using Base = DEFINE_BASE(NonCopyable);
- using Base::Base;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR NonCopyable() DEFINE_DEFAULT_CTOR;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR NonCopyable(NonCopyable const &) = delete;
+struct NonCopyable {
+ DEFINE_EXPLICIT NonCopyable() DEFINE_CTOR;
+ DEFINE_EXPLICIT NonCopyable(NonCopyable const &) = delete;
NonCopyable &operator=(NonCopyable const &) = delete;
DEFINE_DTOR(NonCopyable)
};
-struct MoveOnly : DEFINE_BASE(MoveOnly) {
- using Base = DEFINE_BASE(MoveOnly);
- using Base::Base;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR MoveOnly() DEFINE_DEFAULT_CTOR;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR MoveOnly(MoveOnly &&) DEFINE_CTOR;
+struct MoveOnly {
+ DEFINE_EXPLICIT MoveOnly() DEFINE_CTOR;
+ DEFINE_EXPLICIT MoveOnly(MoveOnly &&) DEFINE_CTOR;
MoveOnly &operator=(MoveOnly &&) DEFINE_ASSIGN;
DEFINE_DTOR(MoveOnly)
};
-struct CopyAssignable : DEFINE_BASE(CopyAssignable) {
- using Base = DEFINE_BASE(CopyAssignable);
- using Base::Base;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyAssignable() = delete;
- CopyAssignable& operator=(CopyAssignable const&) DEFINE_ASSIGN;
- DEFINE_DTOR(CopyAssignable)
-};
-
-struct CopyAssignOnly : DEFINE_BASE(CopyAssignOnly) {
- using Base = DEFINE_BASE(CopyAssignOnly);
- using Base::Base;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyAssignOnly() = delete;
- CopyAssignOnly& operator=(CopyAssignOnly const&) DEFINE_ASSIGN;
- CopyAssignOnly& operator=(CopyAssignOnly &&) = delete;
- DEFINE_DTOR(CopyAssignOnly)
-};
-
-struct MoveAssignOnly : DEFINE_BASE(MoveAssignOnly) {
- using Base = DEFINE_BASE(MoveAssignOnly);
- using Base::Base;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR MoveAssignOnly() = delete;
- MoveAssignOnly& operator=(MoveAssignOnly const&) = delete;
- MoveAssignOnly& operator=(MoveAssignOnly &&) DEFINE_ASSIGN;
- DEFINE_DTOR(MoveAssignOnly)
-};
-
-struct ConvertingType : DEFINE_BASE(ConvertingType) {
- using Base = DEFINE_BASE(ConvertingType);
- using Base::Base;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR ConvertingType() DEFINE_DEFAULT_CTOR;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR ConvertingType(ConvertingType const&)
DEFINE_CTOR;
- DEFINE_EXPLICIT DEFINE_CONSTEXPR ConvertingType(ConvertingType &&)
DEFINE_CTOR;
+struct CopyAssignable {
+ DEFINE_EXPLICIT CopyAssignable() = delete;
+ CopyAssignable& operator=(CopyAssignable const&) DEFINE_ASSIGN;
+ DEFINE_DTOR(CopyAssignable)
+};
+
+struct CopyAssignOnly {
+ DEFINE_EXPLICIT CopyAssignOnly() = delete;
+ CopyAssignOnly& operator=(CopyAssignOnly const&) DEFINE_ASSIGN;
+ CopyAssignOnly& operator=(CopyAssignOnly &&) = delete;
+ DEFINE_DTOR(CopyAssignOnly)
+};
+
+struct MoveAssignOnly {
+ DEFINE_EXPLICIT MoveAssignOnly() = delete;
+ MoveAssignOnly& operator=(MoveAssignOnly const&) = delete;
+ MoveAssignOnly& operator=(MoveAssignOnly &&) DEFINE_ASSIGN;
+ DEFINE_DTOR(MoveAssignOnly)
+};
+
+struct ConvertingType {
+ DEFINE_EXPLICIT ConvertingType() DEFINE_CTOR;
+ DEFINE_EXPLICIT ConvertingType(ConvertingType const&) DEFINE_CTOR;
+ DEFINE_EXPLICIT ConvertingType(ConvertingType &&) DEFINE_CTOR;
ConvertingType& operator=(ConvertingType const&) DEFINE_ASSIGN;
ConvertingType& operator=(ConvertingType &&) DEFINE_ASSIGN;
template <class ...Args>
- DEFINE_EXPLICIT DEFINE_CONSTEXPR ConvertingType(Args&&...) {}
+ DEFINE_EXPLICIT ConvertingType(Args&&...) {}
template <class Arg>
ConvertingType& operator=(Arg&&) { return *this; }
DEFINE_DTOR(ConvertingType)
@@ -142,10 +91,8 @@ struct ConvertingType : DEFINE_BASE(Conv
template <template <class...> class List>
using ApplyTypes = List<
- AllCtors,
- NoCtors,
NoDefault,
- DefaultOnly,
+ AllCtors,
Copyable,
CopyOnly,
NonCopyable,
@@ -156,11 +103,7 @@ using ApplyTypes = List<
ConvertingType
>;
-#undef DEFINE_BASE
#undef DEFINE_EXPLICIT
-#undef DEFINE_CONSTEXPR
-#undef DEFINE_ASSIGN_CONSTEXPR
#undef DEFINE_CTOR
-#undef DEFINE_DEFAULT_CTOR
#undef DEFINE_ASSIGN
-#undef DEFINE_DTOR
\ No newline at end of file
+#undef DEFINE_DTOR
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
