This is an archive of the discontinued LLVM Phabricator instance.

Differential D12486

std::experimental::propagate_const from LFTS v2
ClosedPublic

Authored by jbcoe on Aug 30 2015, 3:01 PM.

Details

Reviewers
mclow.lists
EricWF
Commits
rG945cacc8424b: Implement std::experimental::propagate_const from LFTS v2
rCXX273122: Implement std::experimental::propagate_const from LFTS v2
rL273122: Implement std::experimental::propagate_const from LFTS v2
Summary

An implementation of std::experimental::propagate_const from Library Fundamentals Technical Specification v2.

Tests are provided for specified behaviour (including non-compiling code by checking type_traits).

No tests are provided for disallowed types like fancy pointers or function pointers as no code was written to handle these.

Diff Detail

Repository
rL LLVM

Event Timeline

jbcoe updated this revision to Diff 33549.Aug 30 2015, 3:01 PM
jbcoe retitled this revision from to std::experimental::propagate_const from LFTS v2.
jbcoe updated this object.
jbcoe added reviewers: mclow.lists, EricWF.
EricWF edited edge metadata.Aug 30 2015, 3:17 PM

Awesome and thanks for doing this. I've added some drive-by comments but I haven't really looked at it yet.

I'll start trying to figure out how libc++ should manage shipping both LFTS v1 and LFTS v2 headers.

include/experimental/propagate_const
130 ↗(On Diff #33549)

Anything that isn't in the draft should use a reserved name. So this should probably be __get_pointer.

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.fail.cpp
21 ↗(On Diff #33549)

If the test types X and Y are the same in every test then please lift them into a test header.

EricWF added inline comments.Aug 30 2015, 3:17 PM
include/experimental/propagate_const
11 ↗(On Diff #33549)

_LIBCPP_EXPERIMENTAL_PROPAGATE_CONST please.

126 ↗(On Diff #33549)

_VSTD::declval to prevent ADL.

jbcoe added a comment.Aug 30 2015, 3:23 PM

Is there a good way to see if tests that fail (as expected) are failing for the right reason?

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.fail.cpp
21 ↗(On Diff #33549)

X is always the same and Y is nearly always the same. I can split Y into Y and Y_explicit.
I assume that the test header would go in the root of the propagate_const tests directory?

EricWF added a comment.Aug 30 2015, 3:41 PM
In D12486#236149, @jbcoe wrote:

Is there a good way to see if tests that fail (as expected) are failing for the right reason?

Yes. We use clang verify (http://clang.llvm.org/doxygen/classclang_1_1VerifyDiagnosticConsumer.html#details) to check compilation failure tests. If a *.fail.cpp test contains any verify directives (// expected-{note,warning,error}) then that test is run using clang verify automatically.

Take a look at the following tests for examples:

  • std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/default01.fail.cpp
  • std/thread/futures/futures.promise/copy_ctor.fail.cpp

You only have to supply the expected diagnostics for errors and not notes. Let me know if I can make anything more clear.

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.fail.cpp
21 ↗(On Diff #33549)

I would put the header in libcxx/test/support which is an include directory that all tests share.

jbcoe updated this revision to Diff 33635.Aug 31 2015, 2:59 PM
jbcoe edited edge metadata.

Refactor tests to use helper classes.

Add __ to get_underlying.

Use _VSTD:: for declval to prevent ADL-induced name clashes.

jbcoe marked 5 inline comments as done.Aug 31 2015, 3:01 PM
jbcoe updated this revision to Diff 33636.Aug 31 2015, 3:04 PM

Correctly add _VSTD:: to declval in definition of element_type.

jbcoe marked an inline comment as done.Aug 31 2015, 3:05 PM
jbcoe updated this revision to Diff 33745.Sep 1 2015, 3:31 PM

Correct spelling of 'Constructable'

mclow.lists edited edge metadata.Sep 8 2015, 12:07 PM
In D12486#237757, @jbcoe wrote:

Correct spelling of 'Constructable'

While I approve of this cleanup, I don't think it belongs here - and makes reviewing the propogate_const stuff harder.

jbcoe added a comment.Sep 9 2015, 1:06 PM

This was utterly unintentional and very embarassing. I only mean to amend the propagate-const files.
I'll revert and update the patch.

jbcoe updated this revision to Diff 34364.Sep 9 2015, 1:13 PM
jbcoe edited edge metadata.

Undo spelling correction as it touched many more files than intended.

EricWF added a comment.Oct 6 2015, 5:12 PM

First I think the header is in great shape. I reviewed the constructors and they look good other than the inline nits. I would like to see some more tests though. If a constructor is constexpr then it should have a constexpr test.

I'll try and go through another section of it later this week.

include/experimental/propagate_const
24 ↗(On Diff #34364)

s/__propagate/propagate

112 ↗(On Diff #34364)

You'll want to add this below the include:

#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
154 ↗(On Diff #34364)

Use a reserved name. ie __is_propagate_const.

170 ↗(On Diff #34364)

Just use = default directly. Other C++14 headers already do. Currently this constructor won't compile when _LIBCPP_DEFAULT evaluates to {}

174 ↗(On Diff #34364)

Same as above.

176 ↗(On Diff #34364)

is_convertible<Tp&&, Up> should be equivalent to is_convertible<Tp, Up>.I don't know why the LFTS draft adds the extra reference qualifiers but I"m 95% sure its redundant because declval<Tp>() should already do this for you.

208 ↗(On Diff #34364)

Same as above. Don't use _LIBCPP_DEFAULT here.

jbcoe updated this revision to Diff 37709.Oct 18 2015, 7:00 AM

Address comments from Eric's review. Constexpr tests outstanding (How do I do this?).

jbcoe marked 7 inline comments as done.Oct 18 2015, 7:01 AM
jbcoe updated this revision to Diff 37710.Oct 18 2015, 9:10 AM

constexpr fixes and addition of constexpr to some tests.

I cannot get operator element_type* to work with constexpr - some input here would be good.

jbcoe updated this revision to Diff 37711.Oct 18 2015, 9:14 AM

Use _LIBCXX_CONSTEXPR not constexpr

jbcoe abandoned this revision.Jan 18 2016, 1:34 PM
jbcoe reclaimed this revision.Jan 18 2016, 2:53 PM

Abandoned in error.

EricWF added a comment.Jan 18 2016, 3:01 PM

Phew! I'll try and look through more of this tomorrow.

jbcoe added inline comments.Mar 4 2016, 6:17 PM
test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.fail.cpp
25 ↗(On Diff #37711)

Y is undefined this needs fixing, compiling this file fails for the wrong reason

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp
14 ↗(On Diff #37711)

This comment is not right.

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.fail.cpp
22 ↗(On Diff #37711)

Y is undefined. compilation fails for the wrong reason.

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.fail.cpp
22 ↗(On Diff #37711)

Y is undefined. compilation fails for the wrong reason.

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.fail.cpp
22 ↗(On Diff #37711)

Y is undefined. compilation fails for the wrong reason.

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp
26 ↗(On Diff #37711)

if this is made global then this test will do what's required.

test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp
36 ↗(On Diff #37711)

a test for non-member swap may be needed (just below)

jbcoe marked an inline comment as done.Mar 5 2016, 3:25 PM
jbcoe planned changes to this revision.Mar 22 2016, 4:18 AM
mclow.lists added a comment.Apr 13 2016, 8:47 AM

All the comments seem to be about the tests, which is good (and bad). Good, since the code seems to be pretty solid; bad because it means the tests need more work.

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp
29 ↗(On Diff #37711)

"Will not compile" ?? -- in a test named "xxx.pass.cpp"? Which is correct? The test, the name of the test, or the comment?

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/move_ctor.pass.cpp
27 ↗(On Diff #37711)

"Will not compile" ?? -- in a test named "xxx.pass.cpp"? Which is correct? The test, the name of the test, or the comment?

test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp
22 ↗(On Diff #37711)

Is there some reason that you shouldn't just say:

bool operator<=(const X& lhs, const X& rhs) { return lhs.i <= rhs.i; }

and not open up namespace std?

jbcoe updated this revision to Diff 55188.Apr 27 2016, 4:59 AM
jbcoe marked 9 inline comments as done.

Corrections from Marshall's review.

jbcoe added inline comments.Apr 27 2016, 5:01 AM
test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp
14 ↗(On Diff #37711)

On reflection it looks ok.

test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp
29 ↗(On Diff #37711)

Removed spurious comment.

test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp
23 ↗(On Diff #55188)

no. I've updated code to be more concise.

jbcoe added a comment.May 12 2016, 1:55 PM

Is more work required on this?

mclow.lists added a comment.May 23 2016, 5:26 PM

Jonathan - if you're happy with all the tests, especially if the failing tests fail for the right reasons, then I'm happy with you committing it.

EricWF added a comment.May 23 2016, 6:34 PM

I have some feedback before committing. I'll submit it shortly.

include/experimental/propagate_const
128 ↗(On Diff #37711)

Please add static asserts before this that check 3.7.3[propagate_const.requirments]. This will lead to much nicer diagnostics.

EricWF added a comment.May 23 2016, 8:29 PM

Many of your failure tests can be rewritten as .pass.cpp tests using type traits. Esspecially the ones for the ctors.

For example convertible_element_type.explicit.ctor.fail.cpp can be written as a single static assertion.

static_assert(!is_convertible<int, propagate_const<ExplicitX>>::value, "");

Other than those changes this LGTM like Marshall said.

include/experimental/propagate_const
275 ↗(On Diff #55188)

This call should be unqualified. It can't be implemented directly within the class though. I would do "_VSTD_LFTS_V2::swap(*this, __pt)" here. Please add a test for this of the form:

c++

bool swap_called = false;
void swap(X&, X&) {swap_called = true;}

int main() {
  typedef propagate_const<X> P;
  P p1(1);
  P p2(2);
  p1.swap(p2);
  assert(swap_called);
}
284 ↗(On Diff #55188)

All calls to get_underlying should to be qualified with _VSTD_LFTS_V2. Currently all uses of get_underlying generate a perfect match with the two overloads we provide so it won't be hijacked by ADL but that may change.

EricWF added a comment.May 23 2016, 9:45 PM

FYI I generated some code coverage results for this patch: They can be found here http://efcs.ca/const-coverage/include/experimental/propagate_const.gcov.html.

The stats are misleading because uninstantiated templates aren't counted as uncovered.

jbcoe updated this revision to Diff 58217.May 24 2016, 4:10 AM

All tests are now 'pass' tests as static assert can be used to check for invalid type traits for previous failure cases.

jbcoe updated this object.May 24 2016, 4:13 AM
EricWF added a comment.May 24 2016, 2:28 PM

Once the swap issue is resolved I think this is good to go. @jbcoe do you have commit access?

EricWF resigned from this revision.May 31 2016, 12:47 AM
EricWF removed a reviewer: EricWF.
EricWF added a reviewer: EricWF.
EricWF added a subscriber: EricWF.

Woops, I thought this had landed.

jbcoe updated this revision to Diff 59775.Jun 6 2016, 1:27 PM

ADL-focused fixes from Eric's review (thanks for this).

jbcoe marked 4 inline comments as done.Jun 6 2016, 1:30 PM
jbcoe added inline comments.
include/experimental/propagate_const
129 ↗(On Diff #59775)

Do you mean in the class body?

jbcoe updated this revision to Diff 59789.Jun 6 2016, 2:40 PM

Add static_asserts to class body for constraints on template type.

jbcoe marked 2 inline comments as done.Jun 6 2016, 2:41 PM
jbcoe added inline comments.
include/experimental/propagate_const
130 ↗(On Diff #59789)

I can't see what else you might mean. Perhaps I could add enable_if's but I followed the approach taken in optional.

jbcoe marked an inline comment as done.Jun 8 2016, 1:15 AM
jbcoe added a comment.Jun 17 2016, 3:25 PM

I think I've addressed all comments. Is anything outstanding or is this good to go?

mclow.lists added a comment.Jun 17 2016, 4:41 PM

I've got nothing else. LGTM.

mclow.lists accepted this revision.Jun 17 2016, 4:41 PM
mclow.lists edited edge metadata.
This revision is now accepted and ready to land.Jun 17 2016, 4:41 PM
jbcoe updated this revision to Diff 61198.Jun 19 2016, 4:46 AM
jbcoe edited edge metadata.

Resolve conflict with upstream master to allow arc to apply patch.

Closed by commit rL273122: Implement std::experimental::propagate_const from LFTS v2 (authored by jbcoe). · Explain WhyJun 19 2016, 12:41 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
libcxx/
trunk/
include/
experimental/
4 lines
576 lines
test/
std/
experimental/
utilities/
propagate_const/
propagate_const.class/
propagate_const.assignment/
24 lines
34 lines
25 lines
34 lines
32 lines
33 lines
33 lines
propagate_const.ctors/
28 lines
32 lines
26 lines
28 lines
31 lines
24 lines
28 lines
28 lines
28 lines
propagate_const.non-const_observers/
34 lines
24 lines
34 lines
34 lines
35 lines
propagate_const.observers/
29 lines
26 lines
29 lines
29 lines
28 lines
32 lines
propagate_const.nonmembers/
44 lines
propagate_const.comparison_function_objects/
36 lines
38 lines
38 lines
38 lines
38 lines
36 lines
propagate_const.relops/
64 lines
54 lines
50 lines
55 lines
50 lines
62 lines
31 lines
support/
119 lines

Diff 61217

libcxx/trunk/include/experimental/__config

Show All 19 Lines
#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL namespace std { namespace experimental { #define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL namespace std { namespace experimental {
#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL } } #define _LIBCPP_END_NAMESPACE_EXPERIMENTAL } }
#define _VSTD_EXPERIMENTAL std::experimental #define _VSTD_EXPERIMENTAL std::experimental
#define _LIBCPP_BEGIN_NAMESPACE_LFTS _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v1 { #define _LIBCPP_BEGIN_NAMESPACE_LFTS _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v1 {
#define _LIBCPP_END_NAMESPACE_LFTS } } } #define _LIBCPP_END_NAMESPACE_LFTS } } }
#define _VSTD_LFTS _VSTD_EXPERIMENTAL::fundamentals_v1 #define _VSTD_LFTS _VSTD_EXPERIMENTAL::fundamentals_v1
#define _LIBCPP_BEGIN_NAMESPACE_LFTS_V2 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v2 {
#define _LIBCPP_END_NAMESPACE_LFTS_V2 } } }
#define _VSTD_LFTS_V2 _VSTD_EXPERIMENTAL::fundamentals_v2
#define _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR _LIBCPP_BEGIN_NAMESPACE_LFTS namespace pmr { #define _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR _LIBCPP_BEGIN_NAMESPACE_LFTS namespace pmr {
#define _LIBCPP_END_NAMESPACE_LFTS_PMR _LIBCPP_END_NAMESPACE_LFTS } #define _LIBCPP_END_NAMESPACE_LFTS_PMR _LIBCPP_END_NAMESPACE_LFTS }
#define _VSTD_LFTS_PMR _VSTD_LFTS::pmr #define _VSTD_LFTS_PMR _VSTD_LFTS::pmr
#define _LIBCPP_BEGIN_NAMESPACE_CHRONO_LFTS _LIBCPP_BEGIN_NAMESPACE_STD \ #define _LIBCPP_BEGIN_NAMESPACE_CHRONO_LFTS _LIBCPP_BEGIN_NAMESPACE_STD \
namespace chrono { namespace experimental { inline namespace fundamentals_v1 { namespace chrono { namespace experimental { inline namespace fundamentals_v1 {
#define _LIBCPP_END_NAMESPACE_CHRONO_LFTS _LIBCPP_END_NAMESPACE_STD } } } #define _LIBCPP_END_NAMESPACE_CHRONO_LFTS _LIBCPP_END_NAMESPACE_STD } } }
Show All 11 Lines

libcxx/trunk/include/experimental/propagate_const

// -*- C++ -*-
//===------------------------ propagate_const -----------------------------===//
//
// 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_EXPERIMENTAL_PROPAGATE_CONST
#define _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST
/*
propagate_const synopsis
namespace std { namespace experimental { inline namespace fundamentals_v2 {
// [propagate_const]
template <class T> class propagate_const;
// [propagate_const.underlying], underlying pointer access
constexpr const _Tp& _VSTD_LFTS_V2::get_underlying(const propagate_const<T>& pt) noexcept;
constexpr T& _VSTD_LFTS_V2::get_underlying(propagate_const<T>& pt) noexcept;
// [propagate_const.relational], relational operators
template <class T> constexpr bool operator==(const propagate_const<T>& pt, nullptr_t);
template <class T> constexpr bool operator==(nullptr_t, const propagate_const<T>& pu);
template <class T> constexpr bool operator!=(const propagate_const<T>& pt, nullptr_t);
template <class T> constexpr bool operator!=(nullptr_t, const propagate_const<T>& pu);
template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const _Up& u);
template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const _Up& u);
template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const _Up& u);
template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const _Up& u);
template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const _Up& u);
template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const _Up& u);
template <class T, class U> constexpr bool operator==(const _Tp& t, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator!=(const _Tp& t, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator<(const _Tp& t, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator>(const _Tp& t, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator<=(const _Tp& t, const propagate_const<_Up>& pu);
template <class T, class U> constexpr bool operator>=(const _Tp& t, const propagate_const<_Up>& pu);
// [propagate_const.algorithms], specialized algorithms
template <class T> constexpr void swap(propagate_const<T>& pt, propagate_const<T>& pu) noexcept(see below);
template <class T>
class propagate_const
{
public:
typedef remove_reference_t<decltype(*declval<T&>())> element_type;
// [propagate_const.ctor], constructors
constexpr propagate_const() = default;
propagate_const(const propagate_const& p) = delete;
constexpr propagate_const(propagate_const&& p) = default;
template <class U> EXPLICIT constexpr propagate_const(propagate_const<_Up>&& pu); // see below
template <class U> EXPLICIT constexpr propagate_const(U&& u); // see below
// [propagate_const.assignment], assignment
propagate_const& operator=(const propagate_const& p) = delete;
constexpr propagate_const& operator=(propagate_const&& p) = default;
template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
template <class U> constexpr propagate_const& operator=(U&& u); // see below
// [propagate_const.const_observers], const observers
explicit constexpr operator bool() const;
constexpr const element_type* operator->() const;
constexpr operator const element_type*() const; // Not always defined
constexpr const element_type& operator*() const;
constexpr const element_type* get() const;
// [propagate_const.non_const_observers], non-const observers
constexpr element_type* operator->();
constexpr operator element_type*(); // Not always defined
constexpr element_type& operator*();
constexpr element_type* get();
// [propagate_const.modifiers], modifiers
constexpr void swap(propagate_const& pt) noexcept(see below)
private:
T t_; // exposition only
};
} // namespace fundamentals_v2
} // namespace experimental
// [propagate_const.hash], hash support
template <class T> struct hash<experimental::fundamentals_v2::propagate_const<T>>;
// [propagate_const.comparison_function_objects], comparison function objects
template <class T> struct equal_to<experimental::fundamentals_v2::propagate_const<T>>;
template <class T> struct not_equal_to<experimental::fundamentals_v2::propagate_const<T>>;
template <class T> struct less<experimental::fundamentals_v2::propagate_const<T>>;
template <class T> struct greater<experimental::fundamentals_v2::propagate_const<T>>;
template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>;
template <class T> struct greater_equal<experimental::fundamentals_v2::propagate_const<T>>;
} // namespace std
*/
#include <experimental/__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
#if _LIBCPP_STD_VER > 11
#include <type_traits>
#include <utility>
#include <functional>
_LIBCPP_BEGIN_NAMESPACE_LFTS_V2
template <class _Tp>
class propagate_const;
template <class _Up> _LIBCPP_CONSTEXPR const _Up& get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
template <class _Up> _LIBCPP_CONSTEXPR _Up& get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
template <class _Tp>
class propagate_const
{
public:
typedef remove_reference_t<decltype(*_VSTD::declval<_Tp&>())> element_type;
static_assert(!is_array<_Tp>::value,
"Instantiation of propagate_const with an array type is ill-formed.");
static_assert(!is_reference<_Tp>::value,
"Instantiation of propagate_const with a reference type is ill-formed.");
static_assert(!(is_pointer<_Tp>::value && is_function<typename remove_pointer<_Tp>::type>::value),
"Instantiation of propagate_const with a function-pointer type is ill-formed.");
static_assert(!(is_pointer<_Tp>::value && is_same<typename remove_cv<typename remove_pointer<_Tp>::type>::type, void>::value),
"Instantiation of propagate_const with a pointer to (possibly cv-qualified) void is ill-formed.");
private:
template <class _Up>
static _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up* __u)
{
return __u;
}
template <class _Up>
static _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up& __u)
{
return __get_pointer(__u.get());
}
template <class _Up>
static _LIBCPP_CONSTEXPR const element_type* __get_pointer(const _Up* __u)
{
return __u;
}
template <class _Up>
static _LIBCPP_CONSTEXPR const element_type* __get_pointer(const _Up& __u)
{
return __get_pointer(__u.get());
}
template <class _Up>
struct __is_propagate_const : false_type
{
};
template <class _Up>
struct __is_propagate_const<propagate_const<_Up>> : true_type
{
};
_Tp __t_;
public:
template <class _Up> friend _LIBCPP_CONSTEXPR const _Up& ::_VSTD_LFTS_V2::get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
template <class _Up> friend _LIBCPP_CONSTEXPR _Up& ::_VSTD_LFTS_V2::get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
_LIBCPP_CONSTEXPR propagate_const() = default;
propagate_const(const propagate_const&) = delete;
_LIBCPP_CONSTEXPR propagate_const(propagate_const&&) = default;
template <class _Up, enable_if_t<!is_convertible<_Up, _Tp>::value &&
is_constructible<_Tp, _Up&&>::value,bool> = true>
explicit _LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu)
: __t_(std::move(_VSTD_LFTS_V2::get_underlying(__pu)))
{
}
template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value &&
is_constructible<_Tp, _Up&&>::value,bool> = false>
_LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu)
: __t_(std::move(_VSTD_LFTS_V2::get_underlying(__pu)))
{
}
template <class _Up, enable_if_t<!is_convertible<_Up&&, _Tp>::value &&
is_constructible<_Tp, _Up&&>::value &&
!__is_propagate_const<decay_t<_Up>>::value,bool> = true>
explicit _LIBCPP_CONSTEXPR propagate_const(_Up&& __u)
: __t_(std::forward<_Up>(__u))
{
}
template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value &&
is_constructible<_Tp, _Up&&>::value &&
!__is_propagate_const<decay_t<_Up>>::value,bool> = false>
_LIBCPP_CONSTEXPR propagate_const(_Up&& __u)
: __t_(std::forward<_Up>(__u))
{
}
propagate_const& operator=(const propagate_const&) = delete;
_LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const&&) = default;
template <class _Up>
_LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const<_Up>&& __pu)
{
__t_ = std::move(_VSTD_LFTS_V2::get_underlying(__pu));
return *this;
}
template <class _Up, class _Vp = enable_if_t<!__is_propagate_const<decay_t<_Up>>::value>>
_LIBCPP_CONSTEXPR propagate_const& operator=(_Up&& __u)
{
__t_ = std::forward<_Up>(__u);
return *this;
}
_LIBCPP_CONSTEXPR const element_type* get() const
{
return __get_pointer(__t_);
}
_LIBCPP_CONSTEXPR element_type* get()
{
return __get_pointer(__t_);
}
explicit _LIBCPP_CONSTEXPR operator bool() const
{
return get() != nullptr;
}
_LIBCPP_CONSTEXPR const element_type* operator->() const
{
return get();
}
template <class _Tp_ = _Tp, class _Up = enable_if_t<is_convertible<
const _Tp_, const element_type *>::value>>
_LIBCPP_CONSTEXPR operator const element_type *() const {
return get();
}
_LIBCPP_CONSTEXPR const element_type& operator*() const
{
return *get();
}
_LIBCPP_CONSTEXPR element_type* operator->()
{
return get();
}
template <class _Tp_ = _Tp, class _Up = enable_if_t<
is_convertible<_Tp_, element_type *>::value>>
_LIBCPP_CONSTEXPR operator element_type *() {
return get();
}
_LIBCPP_CONSTEXPR element_type& operator*()
{
return *get();
}
_LIBCPP_CONSTEXPR void swap(propagate_const& __pt) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
{
using _VSTD::swap;
swap(__t_, __pt.__t_);
}
};
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, nullptr_t)
{
return _VSTD_LFTS_V2::get_underlying(__pt) == nullptr;
}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator==(nullptr_t, const propagate_const<_Tp>& __pt)
{
return nullptr == _VSTD_LFTS_V2::get_underlying(__pt);
}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, nullptr_t)
{
return _VSTD_LFTS_V2::get_underlying(__pt) != nullptr;
}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator!=(nullptr_t, const propagate_const<_Tp>& __pt)
{
return nullptr != _VSTD_LFTS_V2::get_underlying(__pt);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt,
const propagate_const<_Up>& __pu)
{
return _VSTD_LFTS_V2::get_underlying(__pt) == _VSTD_LFTS_V2::get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt,
const propagate_const<_Up>& __pu)
{
return _VSTD_LFTS_V2::get_underlying(__pt) != _VSTD_LFTS_V2::get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt,
const propagate_const<_Up>& __pu)
{
return _VSTD_LFTS_V2::get_underlying(__pt) < _VSTD_LFTS_V2::get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt,
const propagate_const<_Up>& __pu)
{
return _VSTD_LFTS_V2::get_underlying(__pt) > _VSTD_LFTS_V2::get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt,
const propagate_const<_Up>& __pu)
{
return _VSTD_LFTS_V2::get_underlying(__pt) <= _VSTD_LFTS_V2::get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt,
const propagate_const<_Up>& __pu)
{
return _VSTD_LFTS_V2::get_underlying(__pt) >= _VSTD_LFTS_V2::get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, const _Up& __u)
{
return _VSTD_LFTS_V2::get_underlying(__pt) == __u;
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, const _Up& __u)
{
return _VSTD_LFTS_V2::get_underlying(__pt) != __u;
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt, const _Up& __u)
{
return _VSTD_LFTS_V2::get_underlying(__pt) < __u;
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt, const _Up& __u)
{
return _VSTD_LFTS_V2::get_underlying(__pt) > __u;
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt, const _Up& __u)
{
return _VSTD_LFTS_V2::get_underlying(__pt) <= __u;
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt, const _Up& __u)
{
return _VSTD_LFTS_V2::get_underlying(__pt) >= __u;
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator==(const _Tp& __t, const propagate_const<_Up>& __pu)
{
return __t == _VSTD_LFTS_V2::get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator!=(const _Tp& __t, const propagate_const<_Up>& __pu)
{
return __t != _VSTD_LFTS_V2::get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator<(const _Tp& __t, const propagate_const<_Up>& __pu)
{
return __t < _VSTD_LFTS_V2::get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator>(const _Tp& __t, const propagate_const<_Up>& __pu)
{
return __t > _VSTD_LFTS_V2::get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator<=(const _Tp& __t, const propagate_const<_Up>& __pu)
{
return __t <= _VSTD_LFTS_V2::get_underlying(__pu);
}
template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR bool operator>=(const _Tp& __t, const propagate_const<_Up>& __pu)
{
return __t >= _VSTD_LFTS_V2::get_underlying(__pu);
}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR void swap(propagate_const<_Tp>& __pc1, propagate_const<_Tp>& __pc2) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
{
using _VSTD::swap;
swap(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR const _Tp& get_underlying(const propagate_const<_Tp>& __pt) _NOEXCEPT
{
return __pt.__t_;
}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR _Tp& get_underlying(propagate_const<_Tp>& __pt) _NOEXCEPT
{
return __pt.__t_;
}
_LIBCPP_END_NAMESPACE_LFTS_V2
_LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp>
struct hash<experimental::fundamentals_v2::propagate_const<_Tp>>
{
typedef size_t result_type;
typedef experimental::fundamentals_v2::propagate_const<_Tp> argument_type;
size_t operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1) const
{
return std::hash<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1));
}
};
template <class _Tp>
struct equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
{
typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
{
return std::equal_to<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
}
};
template <class _Tp>
struct not_equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
{
typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
{
return std::not_equal_to<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
}
};
template <class _Tp>
struct less<experimental::fundamentals_v2::propagate_const<_Tp>>
{
typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
{
return std::less<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
}
};
template <class _Tp>
struct greater<experimental::fundamentals_v2::propagate_const<_Tp>>
{
typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
{
return std::greater<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
}
};
template <class _Tp>
struct less_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
{
typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
{
return std::less_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
}
};
template <class _Tp>
struct greater_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
{
typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
{
return std::greater_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
}
};
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 11
#endif // _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> propagate_const& propagate_const::operator=(const propagate_const<U>&)=delete;
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <type_traits>
using std::experimental::propagate_const;
typedef propagate_const<X> P;
int main() { static_assert(!std::is_assignable<P, const P &>::value, ""); }

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_element_type.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> propagate_const& propagate_const::operator=(U&&);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
int main() {
typedef propagate_const<CopyConstructibleFromX> PY;
X x1(1);
PY p(2);
assert(*p==2);
p = x1;
assert(*p==1);
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> constexpr propagate_const& operator=(U&& u); // won't bind to propagate_const
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <type_traits>
using std::experimental::propagate_const;
typedef propagate_const<X> PX;
typedef propagate_const<CopyConstructibleFromX> PY;
int main() { static_assert(!std::is_assignable<PY, const PX &>::value, ""); }

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> propagate_const& propagate_const::operator=(U&&);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
int main() {
typedef propagate_const<X> P;
X x1(1);
P p(2);
assert(*p==2);
p = x1;
assert(*p==1);
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> propagate_const& propagate_const::operator=(propagate_const<U>&&);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
int main() {
typedef propagate_const<X> P;
P p1(1);
P p2(2);
p2=std::move(p1);
assert(*p2==1);
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> propagate_const& propagate_const::operator=(propagate_const<U>&&);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
int main() {
typedef propagate_const<X> PX;
typedef propagate_const<MoveConstructibleFromX> PY;
PX px2(2);
PY py1(1);
py1=std::move(px2);
assert(*py1==2);
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible_propagate_const.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
int main() {
typedef propagate_const<X> PX;
typedef propagate_const<MoveConstructibleFromX> PY;
PX px2(2);
PY py1(1);
py1=std::move(px2);
assert(*py1==2);
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <type_traits>
using std::experimental::propagate_const;
typedef propagate_const<ExplicitCopyConstructibleFromX> P;
int main() {
static_assert(!std::is_convertible<P, X>::value, "");
static_assert(std::is_constructible<P, X>::value, "");
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.non-explicit.ctor.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> constexpr propagate_const(propagate_const<_Up>&& pu);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
typedef propagate_const<CopyConstructibleFromX> P;
void f(const P& p)
{
assert(*p==2);
}
int main() {
f(X(2));
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> constexpr propagate_const& operator(propagate_const<_Up>&& pu);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <type_traits>
using std::experimental::propagate_const;
typedef propagate_const<X> PX;
typedef propagate_const<CopyConstructibleFromX> PY;
int main() { static_assert(!std::is_constructible<PX, PY>::value, ""); }

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> constexpr propagate_const(propagate_const<_Up>&& pu);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <type_traits>
using std::experimental::propagate_const;
typedef propagate_const<X> PX;
typedef propagate_const<ExplicitMoveConstructibleFromX> PY;
int main() {
static_assert(!std::is_convertible<PY, PX &&>::value, "");
static_assert(std::is_constructible<PY, PX &&>::value, "");
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.move_ctor.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> constexpr propagate_const(propagate_const<_Up>&& pu);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
typedef propagate_const<MoveConstructibleFromX> PY;
typedef propagate_const<X> PX;
int main() {
PX px(1);
PY py(std::move(px));
assert(*py==1);
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/copy_ctor.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// propagate_const(const propagate_const&)=delete;
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <type_traits>
using std::experimental::propagate_const;
typedef propagate_const<X> P;
int main() { static_assert(!std::is_constructible<P, const P &>::value, ""); }

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.explicit.ctor.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> propagate_const(U&&);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <type_traits>
using std::experimental::propagate_const;
typedef propagate_const<ExplicitX> P;
int main() {
static_assert(!std::is_convertible<P, int>::value, "");
static_assert(std::is_constructible<P, int>::value, "");
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class U> propagate_const(U&&);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
typedef propagate_const<X> P;
void f(const P&)
{
}
int main() { f(2); }

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/move_ctor.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// propagate_const(propagate_const&&)=default;
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
int main() {
typedef propagate_const<X> P;
P p1(2);
P p2(std::move(p1));
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/dereference.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// element_type& propagate_const::operator*();
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
typedef propagate_const<X> P;
constexpr P f()
{
P p(1);
*p = 2;
return p;
}
int main() {
constexpr P p = f();
static_assert(*p==2,"");
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/explicit_operator_element_type_ptr.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// propagate_const::operator element_type*();
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <type_traits>
using std::experimental::propagate_const;
typedef propagate_const<X> P;
int main() { static_assert(!std::is_convertible<P, int *>::value, ""); }

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/get.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// element_type* propagate_const::get();
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
typedef propagate_const<X> P;
constexpr P f()
{
P p(1);
*p.get() = 2;
return p;
}
int main() {
constexpr P p = f();
static_assert(*(p.get())==2,"");
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/op_arrow.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// element_type* propagate_const::operator->();
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
typedef propagate_const<X> P;
constexpr P f()
{
P p(1);
*(p.operator->()) = 2;
return p;
}
int main() {
constexpr P p = f();
static_assert(*(p.operator->())==2,"");
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// propagate_const::operator element_type*();
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
int main() {
typedef propagate_const<XWithImplicitIntStarConversion> P;
P p(1);
int* ptr_1 = p;
assert(*ptr_1==1);
*ptr_1 = 2;
assert(*ptr_1==2);
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/dereference.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// const element_type& propagate_const::operator*() const;
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
int main() {
typedef propagate_const<X> P;
constexpr P p(1);
static_assert(*p==1,"");
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/explicit_operator_element_type_ptr.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// propagate_const::operator const element_type*() const;
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <type_traits>
using std::experimental::propagate_const;
typedef propagate_const<X> P;
int main() {
static_assert(!std::is_convertible<const P, const int *>::value, "");
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/get.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// const element_type* propagate_const::get() const;
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
int main() {
typedef propagate_const<X> P;
constexpr P p(1);
static_assert(*(p.get())==1, "");
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/op_arrow.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// const element_type* propagate_const::operator->() const;
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
int main() {
typedef propagate_const<X> P;
constexpr P p(1);
static_assert(*(p.operator->())==1,"");
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// propagate_const::operator const element_type*() const;
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
typedef propagate_const<XWithImplicitConstIntStarConversion> P;
constexpr P p(1);
constexpr const int *ptr_1 = p;
int main() { assert(*ptr_1 == 1); }

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class T> constexpr void propagate_const::swap(propagate_const<T>& x);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
bool swap_called = false;
void swap(X &, X &) { swap_called = true; }
int main() {
typedef propagate_const<X> P;
P p1(1);
P p2(2);
p1.swap(p2);
assert(swap_called);
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/hash.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class T> struct hash<experimental::fundamentals_v2::propagate_const<T>>;
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
namespace std {
template <> struct hash<X>
{
typedef X first_argument_type;
size_t operator()(const first_argument_type& x1) const
{
return 99;
}
};
} // namespace std
int main() {
typedef propagate_const<X> P;
P p(1);
auto h = std::hash<P>();
assert(h(p)==99);
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/equal_to.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class T> struct equal_to<experimental::fundamentals_v2::propagate_const<T>>;
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
constexpr bool operator==(const X &x1, const X &x2) { return x1.i_ == x2.i_; }
int main() {
typedef propagate_const<X> P;
P p1_1(1);
P p2_1(1);
P p3_2(2);
auto c = std::equal_to<P>();
assert(c(p1_1,p2_1));
assert(!c(p1_1,p3_2));
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class T> struct greater<experimental::fundamentals_v2::propagate_const<T>>;
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
constexpr bool operator>(const X &x1, const X &x2) { return x1.i_ > x2.i_; }
int main() {
typedef propagate_const<X> P;
P p1_1(1);
P p2_1(1);
P p3_2(2);
auto c = std::greater<P>();
assert(!c(p1_1,p2_1));
assert(!c(p2_1,p1_1));
assert(!c(p1_1,p3_2));
assert(c(p3_2,p1_1));
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater_equal.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class T> struct greater_equal<experimental::fundamentals_v2::propagate_const<T>>;
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
constexpr bool operator>=(const X &x1, const X &x2) { return x1.i_ >= x2.i_; }
int main() {
typedef propagate_const<X> P;
P p1_1(1);
P p2_1(1);
P p3_2(2);
auto c = std::greater_equal<P>();
assert(c(p1_1,p2_1));
assert(c(p2_1,p1_1));
assert(!c(p1_1,p3_2));
assert(c(p3_2,p1_1));
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class T> struct less<experimental::fundamentals_v2::propagate_const<T>>;
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
constexpr bool operator<(const X &x1, const X &x2) { return x1.i_ < x2.i_; }
int main() {
typedef propagate_const<X> P;
P p1_1(1);
P p2_1(1);
P p3_2(2);
auto c = std::less<P>();
assert(!c(p1_1,p2_1));
assert(!c(p2_1,p1_1));
assert(c(p1_1,p3_2));
assert(!c(p3_2,p1_1));
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>;
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
constexpr bool operator<=(const X &x1, const X &x2) { return x1.i_ <= x2.i_; }
int main() {
typedef propagate_const<X> P;
P p1_1(1);
P p2_1(1);
P p3_2(2);
auto c = std::less_equal<P>();
assert(c(p1_1,p2_1));
assert(c(p2_1,p1_1));
assert(c(p1_1,p3_2));
assert(!c(p3_2,p1_1));
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/not_equal_to.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class T> struct not_equal_to<experimental::fundamentals_v2::propagate_const<T>>;
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
constexpr bool operator!=(const X &x1, const X &x2) { return x1.i_ != x2.i_; }
int main() {
typedef propagate_const<X> P;
P p1_1(1);
P p2_1(1);
P p3_2(2);
auto c = std::not_equal_to<P>();
assert(!c(p1_1,p2_1));
assert(c(p1_1,p3_2));
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/equal.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class T> constexpr bool operator==(const propagate_const<T>& x, const propagate_const<T>& y);
// template <class T> constexpr bool operator==(const T& x, const propagate_const<T>& y);
// template <class T> constexpr bool operator==(const propagate_const<T>& x, const T& y);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
using std::nullptr_t;
constexpr bool operator==(const X &lhs, const X &rhs) {
return lhs.i_ == rhs.i_;
}
constexpr bool operator==(const X &, const nullptr_t &) {
return false;
}
constexpr bool operator==(const nullptr_t &, const X &) {
return false;
}
int main() {
constexpr X x1_1(1);
constexpr X x2_1(1);
constexpr X x3_2(2);
static_assert(x1_1 == x1_1, "");
static_assert(x1_1 == x2_1, "");
static_assert(!(x1_1 == x3_2), "");
typedef propagate_const<X> P;
constexpr P p1_1(1);
constexpr P p2_1(1);
constexpr P p3_2(2);
static_assert(p1_1 == p1_1, "");
static_assert(p1_1 == p2_1, "");
static_assert(!(p1_1 == p3_2), "");
static_assert(x1_1 == p1_1, "");
static_assert(!(x1_1 == p3_2), "");
static_assert(p1_1 == x1_1, "");
static_assert(!(p1_1 == x3_2), "");
static_assert(!(p1_1==nullptr),"");
static_assert(!(nullptr==p1_1),"");
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_equal.pass.cpp

//>==---------------------------------------------------------------------->==//
//
// 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.
//
//>==---------------------------------------------------------------------->==//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class T> constexpr bool operator>=(const propagate_const<T>& x, const propagate_const<T>& y);
// template <class T> constexpr bool operator>=(const T& x, const propagate_const<T>& y);
// template <class T> constexpr bool operator>=(const propagate_const<T>& x, const T& y);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
constexpr bool operator>=(const X &lhs, const X &rhs) {
return lhs.i_ >= rhs.i_;
}
int main() {
constexpr X x1_1(1);
constexpr X x2_1(1);
constexpr X x3_2(2);
static_assert(x1_1 >= x2_1, "");
static_assert(!(x1_1 >= x3_2), "");
static_assert(x3_2 >= x1_1, "");
typedef propagate_const<X> P;
constexpr P p1_1(1);
constexpr P p2_1(1);
constexpr P p3_2(2);
static_assert(p1_1 >= p2_1, "");
static_assert(!(p1_1 >= p3_2), "");
static_assert(p3_2 >= p1_1, "");
static_assert(p1_1 >= x2_1, "");
static_assert(!(p1_1 >= x3_2), "");
static_assert(p3_2 >= x1_1, "");
static_assert(x1_1 >= p2_1, "");
static_assert(!(x1_1 >= p3_2), "");
static_assert(x3_2 >= p1_1, "");
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_than.pass.cpp

//>=---------------------------------------------------------------------->=//
//
// 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.
//
//>=---------------------------------------------------------------------->=//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class T> constexpr bool operator>(const propagate_const<T>& x, const propagate_const<T>& y);
// template <class T> constexpr bool operator>(const T& x, const propagate_const<T>& y);
// template <class T> constexpr bool operator>(const propagate_const<T>& x, const T& y);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
constexpr bool operator>(const X &lhs, const X &rhs) {
return lhs.i_ > rhs.i_;
}
int main() {
constexpr X x1_1(1);
constexpr X x2_1(1);
constexpr X x3_2(2);
static_assert(!(x1_1 > x2_1), "");
static_assert(x3_2 > x1_1, "");
typedef propagate_const<X> P;
constexpr P p1_1(1);
constexpr P p2_1(1);
constexpr P p3_2(2);
static_assert(!(p1_1 > p2_1), "");
static_assert(p3_2 > p1_1, "");
static_assert(!(p1_1 > x2_1), "");
static_assert(p3_2 > x1_1, "");
static_assert(!(x1_1 > p2_1), "");
static_assert(x3_2 > p1_1, "");
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_equal.pass.cpp

//<==----------------------------------------------------------------------<==//
//
// 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.
//
//<==----------------------------------------------------------------------<==//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class T> constexpr bool operator<=(const propagate_const<T>& x, const propagate_const<T>& y);
// template <class T> constexpr bool operator<=(const T& x, const propagate_const<T>& y);
// template <class T> constexpr bool operator<=(const propagate_const<T>& x, const T& y);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
constexpr bool operator<=(const X &lhs, const X &rhs) {
return lhs.i_ <= rhs.i_;
}
int main() {
constexpr X x1_1(1);
constexpr X x2_1(1);
constexpr X x3_2(2);
static_assert(x1_1 <= x2_1, "");
static_assert(x1_1 <= x3_2, "");
static_assert(!(x3_2 <= x1_1), "");
typedef propagate_const<X> P;
constexpr P p1_1(1);
constexpr P p2_1(1);
constexpr P p3_2(2);
static_assert(p1_1 <= p2_1, "");
static_assert(p1_1 <= p3_2, "");
static_assert(!(p3_2 <= p1_1), "");
static_assert(p1_1 <= x2_1, "");
static_assert(p1_1 <= x3_2, "");
static_assert(!(p3_2 <= x1_1), "");
static_assert(x1_1 <= p2_1, "");
static_assert(x1_1 <= p3_2, "");
static_assert(!(x3_2 <= p1_1), "");
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_than.pass.cpp

//<=----------------------------------------------------------------------<=//
//
// 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.
//
//<=----------------------------------------------------------------------<=//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class T> constexpr bool operator<(const propagate_const<T>& x, const propagate_const<T>& y);
// template <class T> constexpr bool operator<(const T& x, const propagate_const<T>& y);
// template <class T> constexpr bool operator<(const propagate_const<T>& x, const T& y);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
constexpr bool operator<(const X &lhs, const X &rhs) {
return lhs.i_ < rhs.i_;
}
int main() {
constexpr X x1_1(1);
constexpr X x2_1(1);
constexpr X x3_2(2);
static_assert(!(x1_1 < x2_1), "");
static_assert(x1_1 < x3_2, "");
typedef propagate_const<X> P;
constexpr P p1_1(1);
constexpr P p2_1(1);
constexpr P p3_2(2);
static_assert(!(p1_1 < p2_1), "");
static_assert(p1_1 < p3_2, "");
static_assert(!(x1_1 < p1_1), "");
static_assert(x1_1 < p3_2, "");
static_assert(!(p1_1 < x1_1), "");
static_assert(p1_1 < x3_2, "");
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/not_equal.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class T> constexpr bool operator!=(const propagate_const<T>& x, const propagate_const<T>& y);
// template <class T> constexpr bool operator!=(const T& x, const propagate_const<T>& y);
// template <class T> constexpr bool operator!=(const propagate_const<T>& x, const T& y);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
using std::nullptr_t;
constexpr bool operator!=(const X &lhs, const X &rhs) {
return lhs.i_ != rhs.i_;
}
constexpr bool operator!=(const X &, const nullptr_t &) {
return true;
}
constexpr bool operator!=(const nullptr_t &, const X &) {
return true;
}
int main() {
constexpr X x1_1(1);
constexpr X x2_1(1);
constexpr X x3_2(2);
static_assert(!(x1_1 != x2_1), "");
static_assert(x1_1 != x3_2, "");
typedef propagate_const<X> P;
constexpr P p1_1(1);
constexpr P p2_1(1);
constexpr P p3_2(2);
static_assert(!(p1_1 != p2_1), "");
static_assert(p1_1 != p3_2, "");
static_assert(!(x1_1 != p1_1), "");
static_assert(x1_1 != p3_2, "");
static_assert(!(p1_1 != x1_1), "");
static_assert(p1_1 != x3_2, "");
static_assert(p1_1!=nullptr,"");
static_assert(nullptr!=p1_1,"");
}

libcxx/trunk/test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/swap.pass.cpp

//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <propagate_const>
// template <class T> constexpr void swap(propagate_const<T>& x, propagate_const<T>& y);
#include <experimental/propagate_const>
#include "propagate_const_helpers.h"
#include <cassert>
using std::experimental::propagate_const;
bool swap_called = false;
void swap(X &, X &) { swap_called = true; }
int main() {
typedef propagate_const<X> P;
P p1(1);
P p2(2);
swap(p1, p2);
assert(swap_called);
}

libcxx/trunk/test/support/propagate_const_helpers.h

// A lightweight class, with pointer-like methods, that contains an int
struct X
{
int i_;
constexpr const int &operator*() const { return i_; }
constexpr int &operator*() { return i_; }
constexpr const int *get() const { return &i_; }
constexpr int *get() { return &i_; }
constexpr const int *operator->() const { return &i_; }
constexpr int *operator->() { return &i_; }
constexpr X(int i) : i_(i) {}
};
struct XWithImplicitIntStarConversion
{
int i_;
constexpr const int &operator*() const { return i_; }
constexpr int &operator*() { return i_; }
constexpr const int *get() const { return &i_; }
constexpr int *get() { return &i_; }
constexpr const int *operator->() const { return &i_; }
constexpr int *operator->() { return &i_; }
constexpr operator int* () { return &i_; }
constexpr XWithImplicitIntStarConversion(int i) : i_(i) {}
};
struct XWithImplicitConstIntStarConversion
{
int i_;
constexpr const int &operator*() const { return i_; }
constexpr int &operator*() { return i_; }
constexpr const int *get() const { return &i_; }
constexpr int *get() { return &i_; }
constexpr const int *operator->() const { return &i_; }
constexpr int *operator->() { return &i_; }
constexpr operator const int* () const { return &i_; }
constexpr XWithImplicitConstIntStarConversion(int i) : i_(i) {}
};
struct ExplicitX
{
int i_;
constexpr const int &operator*() const { return i_; }
constexpr int &operator*() { return i_; }
constexpr const int *get() const { return &i_; }
constexpr int *get() { return &i_; }
constexpr const int *operator->() const { return &i_; }
constexpr int *operator->() { return &i_; }
constexpr explicit ExplicitX(int i) : i_(i) {}
};
struct MoveConstructibleFromX
{
int i_;
constexpr const int &operator*() const { return i_; }
constexpr int &operator*() { return i_; }
constexpr const int *get() const { return &i_; }
constexpr int *get() { return &i_; }
constexpr const int *operator->() const { return &i_; }
constexpr int *operator->() { return &i_; }
constexpr MoveConstructibleFromX(int i) : i_(i) {}
constexpr MoveConstructibleFromX(X&& x) : i_(x.i_) {}
};
struct ExplicitMoveConstructibleFromX
{
int i_;
constexpr const int &operator*() const { return i_; }
constexpr int &operator*() { return i_; }
constexpr const int *get() const { return &i_; }
constexpr int *get() { return &i_; }
constexpr const int *operator->() const { return &i_; }
constexpr int *operator->() { return &i_; }
constexpr ExplicitMoveConstructibleFromX(int i) : i_(i) {}
constexpr explicit ExplicitMoveConstructibleFromX(X&& x) : i_(x.i_) {}
};
struct CopyConstructibleFromX
{
int i_;
constexpr const int &operator*() const { return i_; }
constexpr int &operator*() { return i_; }
constexpr const int *get() const { return &i_; }
constexpr int *get() { return &i_; }
constexpr const int *operator->() const { return &i_; }
constexpr int *operator->() { return &i_; }
constexpr CopyConstructibleFromX(int i) : i_(i) {}
constexpr CopyConstructibleFromX(const X& x) : i_(x.i_) {}
};
struct ExplicitCopyConstructibleFromX
{
int i_;
constexpr const int &operator*() const { return i_; }
constexpr int &operator*() { return i_; }
constexpr const int *get() const { return &i_; }
constexpr int *get() { return &i_; }
constexpr const int *operator->() const { return &i_; }
constexpr int *operator->() { return &i_; }
constexpr ExplicitCopyConstructibleFromX(int i) : i_(i) {}
constexpr explicit ExplicitCopyConstructibleFromX(const X& x) : i_(x.i_) {}
};