static bool sThrows;
};
-
+
bool Throws::sThrows = false;
#endif
static bool sThrows;
};
-
+
bool Throws::sThrows = false;
#endif
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// template<class T, ptrdiff_t X, class U, ptrdiff_t Y>
// constexpr bool operator==(span<T, X> l, span<U, Y> r);
-//
+//
//
// Effects: Equivalent to: return equal(l.begin(), l.end(), r.begin(), r.end());
//
int iArr2[] = { 0, 1, 2, 1, 2, 5, 6, 7, 8, 9};
constexpr float fArr1[] = {0., 1., 2., 1., 2., 5., 6., 7., 8., 9.};
float fArr2[] = {0., 1., 2., 1., 2., 5., 6., 7., 8., 9.};
-
+
int main () {
static_assert( (csp0s == csp0s), "");
static_assert( (csp0s == csp0d), "");
static_assert( (csp0d == csp0s), "");
-
+
static_assert(!(csp0d == csp1d), "");
static_assert(!(csp0s == csp1s), "");
static_assert(!(csp0s == csp1d), "");
static_assert(!(csp0d == csp1s), "");
-
+
static_assert( (csp1d == csp1s), "");
static_assert( (csp1s == csp1d), "");
-
+
static_assert( (csp2d == csp3d), "");
static_assert( (csp2s == csp3s), "");
static_assert( (csp2d == csp3s), "");
assert( (sp0s == sp0s));
assert( (sp0s == sp0d));
assert( (sp0d == sp0s));
-
+
assert(!(sp0d == sp1d));
assert(!(sp0s == sp1s));
assert(!(sp0s == sp1d));
assert(!(sp0d == sp1s));
-
+
assert( (sp1d == sp1s));
assert( (sp1s == sp1d));
-
+
assert( (sp2d == sp3d));
assert( (sp2s == sp3s));
assert( (sp2d == sp3s));
assert( (csp0s == sp0s));
assert( (csp0s == sp0d));
assert( (csp0d == sp0s));
-
+
assert(!(csp0d == sp1d));
assert(!(csp0s == sp1s));
assert(!(csp0s == sp1d));
assert(!(csp0d == sp1s));
-
+
assert( (csp1d == sp1s));
assert( (csp1s == sp1d));
-
+
assert( (csp2d == sp3d));
assert( (csp2s == sp3s));
assert( (csp2d == sp3s));
assert(!(csp2s == sp4s));
assert(!(csp2d == sp4s));
assert(!(csp2s == sp4d));
-
+
assert(!(csp4d == sp2d));
assert(!(csp4s == sp2s));
assert(!(csp4d == sp2s));
assert(std::span<int>{iArr2} == std::span<float>{fArr2});
static_assert(!(std::span<const int>{iArr1, 9} == std::span<const float>{fArr1, 8}), "");
-}
\ No newline at end of file
+}
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// template<class T, ptrdiff_t X, class U, ptrdiff_t Y>
// constexpr bool operator>=(span<T, X> l, span<U, Y> r);
-//
+//
//
// Effects: Equivalent to: return !(l < r);
//
int iArr2[] = { 0, 1, 2, 1, 2, 5, 6, 7, 8, 9};
constexpr float fArr1[] = {0., 1., 2., 1., 2., 5., 6., 7., 8., 9.};
float fArr2[] = {0., 1., 2., 1., 2., 5., 6., 7., 8., 9.};
-
+
int main () {
static_assert( (csp0s >= csp0s), "");
static_assert( (csp0s >= csp0d), "");
static_assert( (csp0d >= csp0s), "");
-
+
static_assert(!(csp0d >= csp1d), "");
static_assert(!(csp0s >= csp1s), "");
static_assert(!(csp0s >= csp1d), "");
static_assert(!(csp0d >= csp1s), "");
-
+
static_assert( (csp1d >= csp1s), "");
static_assert( (csp1s >= csp1d), "");
-
+
static_assert( (csp2d >= csp3d), "");
static_assert( (csp2s >= csp3s), "");
static_assert( (csp2d >= csp3s), "");
assert( (sp0s >= sp0s));
assert( (sp0s >= sp0d));
assert( (sp0d >= sp0s));
-
+
assert(!(sp0d >= sp1d));
assert(!(sp0s >= sp1s));
assert(!(sp0s >= sp1d));
assert(!(sp0d >= sp1s));
-
+
assert( (sp1d >= sp1s));
assert( (sp1s >= sp1d));
-
+
assert( (sp2d >= sp3d));
assert( (sp2s >= sp3s));
assert( (sp2d >= sp3s));
assert( (csp0s >= sp0s));
assert( (csp0s >= sp0d));
assert( (csp0d >= sp0s));
-
+
assert(!(csp0d >= sp1d));
assert(!(csp0s >= sp1s));
assert(!(csp0s >= sp1d));
assert(!(csp0d >= sp1s));
-
+
assert( (csp1d >= sp1s));
assert( (csp1s >= sp1d));
-
+
assert( (csp2d >= sp3d));
assert( (csp2s >= sp3s));
assert( (csp2d >= sp3s));
assert(!(csp2s >= sp4s));
assert(!(csp2d >= sp4s));
assert(!(csp2s >= sp4d));
-
+
assert( (csp4d > sp2d));
assert( (csp4s > sp2s));
assert( (csp4d > sp2s));
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// template<class T, ptrdiff_t X, class U, ptrdiff_t Y>
// constexpr bool operator>(span<T, X> l, span<U, Y> r);
-//
+//
//
// Effects: Equivalent to: return (r < l);
//
int iArr2[] = { 0, 1, 2, 1, 2, 5, 6, 7, 8, 9};
constexpr float fArr1[] = {0., 1., 2., 1., 2., 5., 6., 7., 8., 9.};
float fArr2[] = {0., 1., 2., 1., 2., 5., 6., 7., 8., 9.};
-
+
int main () {
static_assert(!(csp0s > csp0s), "");
static_assert(!(csp0s > csp0d), "");
static_assert(!(csp0d > csp0s), "");
-
+
static_assert(!(csp0d > csp1d), "");
static_assert(!(csp0s > csp1s), "");
static_assert(!(csp0s > csp1d), "");
static_assert(!(csp0d > csp1s), "");
-
+
static_assert(!(csp1d > csp1s), "");
static_assert(!(csp1s > csp1d), "");
-
+
static_assert(!(csp2d > csp3d), "");
static_assert(!(csp2s > csp3s), "");
static_assert(!(csp2d > csp3s), "");
assert(!(sp0s > sp0s));
assert(!(sp0s > sp0d));
assert(!(sp0d > sp0s));
-
+
assert(!(sp0d > sp1d));
assert(!(sp0s > sp1s));
assert(!(sp0s > sp1d));
assert(!(sp0d > sp1s));
-
+
assert(!(sp1d > sp1s));
assert(!(sp1s > sp1d));
-
+
assert(!(sp2d > sp3d));
assert(!(sp2s > sp3s));
assert(!(sp2d > sp3s));
assert(!(csp0s > sp0s));
assert(!(csp0s > sp0d));
assert(!(csp0d > sp0s));
-
+
assert(!(csp0d > sp1d));
assert(!(csp0s > sp1s));
assert(!(csp0s > sp1d));
assert(!(csp0d > sp1s));
-
+
assert(!(csp1d > sp1s));
assert(!(csp1s > sp1d));
-
+
assert(!(csp2d > sp3d));
assert(!(csp2s > sp3s));
assert(!(csp2d > sp3s));
assert(!(csp2s > sp4s));
assert(!(csp2d > sp4s));
assert(!(csp2s > sp4d));
-
+
assert( (csp4d > sp2d));
assert( (csp4s > sp2s));
assert( (csp4d > sp2s));
assert(!(std::span<int>{iArr2} > std::span<float>{fArr2}));
static_assert( (std::span<const int>{iArr1, 9} > std::span<const float>{fArr1, 8}), "");
-}
\ No newline at end of file
+}
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// template<class T, ptrdiff_t X, class U, ptrdiff_t Y>
// constexpr bool operator<=(span<T, X> l, span<U, Y> r);
-//
+//
//
// Effects: Equivalent to: return !(r < l);
//
int iArr2[] = { 0, 1, 2, 1, 2, 5, 6, 7, 8, 9};
constexpr float fArr1[] = {0., 1., 2., 1., 2., 5., 6., 7., 8., 9.};
float fArr2[] = {0., 1., 2., 1., 2., 5., 6., 7., 8., 9.};
-
+
int main () {
static_assert( (csp0s <= csp0s), "");
static_assert( (csp0s <= csp0d), "");
static_assert( (csp0d <= csp0s), "");
-
+
static_assert( (csp0d <= csp1d), "");
static_assert( (csp0s <= csp1s), "");
static_assert( (csp0s <= csp1d), "");
static_assert( (csp0d <= csp1s), "");
-
+
static_assert( (csp1d <= csp1s), "");
static_assert( (csp1s <= csp1d), "");
-
+
static_assert( (csp2d <= csp3d), "");
static_assert( (csp2s <= csp3s), "");
static_assert( (csp2d <= csp3s), "");
assert( (sp0s <= sp0s));
assert( (sp0s <= sp0d));
assert( (sp0d <= sp0s));
-
+
assert( (sp0d <= sp1d));
assert( (sp0s <= sp1s));
assert( (sp0s <= sp1d));
assert( (sp0d <= sp1s));
-
+
assert( (sp1d <= sp1s));
assert( (sp1s <= sp1d));
-
+
assert( (sp2d <= sp3d));
assert( (sp2s <= sp3s));
assert( (sp2d <= sp3s));
assert( (csp0s <= sp0s));
assert( (csp0s <= sp0d));
assert( (csp0d <= sp0s));
-
+
assert( (csp0d <= sp1d));
assert( (csp0s <= sp1s));
assert( (csp0s <= sp1d));
assert( (csp0d <= sp1s));
-
+
assert( (csp1d <= sp1s));
assert( (csp1s <= sp1d));
-
+
assert( (csp2d <= sp3d));
assert( (csp2s <= sp3s));
assert( (csp2d <= sp3s));
assert( (csp2s <= sp4s));
assert( (csp2d <= sp4s));
assert( (csp2s <= sp4d));
-
+
assert(!(csp4d <= sp2d));
assert(!(csp4s <= sp2s));
assert(!(csp4d <= sp2s));
static_assert(std::span<const int>{iArr1, 8} <= std::span<const float>{fArr1, 9}, "");
assert( (std::span<float>{fArr2} <= std::span<int>{iArr2}));
assert( (std::span<int>{iArr2} <= std::span<float>{fArr2}));
-
+
static_assert(!(std::span<const int>{iArr1, 9} <= std::span<const float>{fArr1, 8}), "");
-}
\ No newline at end of file
+}
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// template<class T, ptrdiff_t X, class U, ptrdiff_t Y>
// constexpr bool operator<(span<T, X> l, span<U, Y> r);
-//
+//
//
// Effects: Equivalent to:
// return lexicographical_compare(l.begin(), l.end(), r.begin(), r.end());
int iArr2[] = { 0, 1, 2, 1, 2, 5, 6, 7, 8, 9};
constexpr float fArr1[] = {0., 1., 2., 1., 2., 5., 6., 7., 8., 9.};
float fArr2[] = {0., 1., 2., 1., 2., 5., 6., 7., 8., 9.};
-
+
int main () {
static_assert(!(csp0s < csp0s), "");
static_assert(!(csp0s < csp0d), "");
static_assert(!(csp0d < csp0s), "");
-
+
static_assert( (csp0d < csp1d), "");
static_assert( (csp0s < csp1s), "");
static_assert( (csp0s < csp1d), "");
static_assert( (csp0d < csp1s), "");
-
+
static_assert(!(csp1d < csp1s), "");
static_assert(!(csp1s < csp1d), "");
-
+
static_assert(!(csp2d < csp3d), "");
static_assert(!(csp2s < csp3s), "");
static_assert(!(csp2d < csp3s), "");
assert(!(sp0s < sp0s));
assert(!(sp0s < sp0d));
assert(!(sp0d < sp0s));
-
+
assert( (sp0d < sp1d));
assert( (sp0s < sp1s));
assert( (sp0s < sp1d));
assert( (sp0d < sp1s));
-
+
assert(!(sp1d < sp1s));
assert(!(sp1s < sp1d));
-
+
assert(!(sp2d < sp3d));
assert(!(sp2s < sp3s));
assert(!(sp2d < sp3s));
assert(!(csp0s < sp0s));
assert(!(csp0s < sp0d));
assert(!(csp0d < sp0s));
-
+
assert( (csp0d < sp1d));
assert( (csp0s < sp1s));
assert( (csp0s < sp1d));
assert( (csp0d < sp1s));
-
+
assert(!(csp1d < sp1s));
assert(!(csp1s < sp1d));
-
+
assert(!(csp2d < sp3d));
assert(!(csp2s < sp3s));
assert(!(csp2d < sp3s));
assert( (csp2s < sp4s));
assert( (csp2d < sp4s));
assert( (csp2s < sp4d));
-
+
assert(!(csp4d < sp2d));
assert(!(csp4s < sp2s));
assert(!(csp4d < sp2s));
assert(!(std::span<float>{fArr2} < std::span<int>{iArr2}));
assert(!(std::span<int>{iArr2} < std::span<float>{fArr2}));
- static_assert(!(std::span<const int>{iArr1, 9} < std::span<const float>{fArr1, 8}), "");
-}
\ No newline at end of file
+ static_assert(!(std::span<const int>{iArr1, 9} < std::span<const float>{fArr1, 8}), "");
+}
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// template<class T, ptrdiff_t X, class U, ptrdiff_t Y>
// constexpr bool operator!=(span<T, X> l, span<U, Y> r);
-//
+//
//
// Effects: Equivalent to: return !(l == r);
//
int iArr2[] = { 0, 1, 2, 1, 2, 5, 6, 7, 8, 9};
constexpr float fArr1[] = {0., 1., 2., 1., 2., 5., 6., 7., 8., 9.};
float fArr2[] = {0., 1., 2., 1., 2., 5., 6., 7., 8., 9.};
-
+
int main () {
static_assert(!(csp0s != csp0s), "");
static_assert(!(csp0s != csp0d), "");
static_assert(!(csp0d != csp0s), "");
-
+
static_assert( (csp0d != csp1d), "");
static_assert( (csp0s != csp1s), "");
static_assert( (csp0s != csp1d), "");
static_assert( (csp0d != csp1s), "");
-
+
static_assert(!(csp1d != csp1s), "");
static_assert(!(csp1s != csp1d), "");
-
+
static_assert(!(csp2d != csp3d), "");
static_assert(!(csp2s != csp3s), "");
static_assert(!(csp2d != csp3s), "");
assert(!(sp0s != sp0s));
assert(!(sp0s != sp0d));
assert(!(sp0d != sp0s));
-
+
assert( (sp0d != sp1d));
assert( (sp0s != sp1s));
assert( (sp0s != sp1d));
assert( (sp0d != sp1s));
-
+
assert(!(sp1d != sp1s));
assert(!(sp1s != sp1d));
-
+
assert(!(sp2d != sp3d));
assert(!(sp2s != sp3s));
assert(!(sp2d != sp3s));
assert(!(csp0s != sp0s));
assert(!(csp0s != sp0d));
assert(!(csp0d != sp0s));
-
+
assert( (csp0d != sp1d));
assert( (csp0s != sp1s));
assert( (csp0s != sp1d));
assert( (csp0d != sp1s));
-
+
assert(!(csp1d != sp1s));
assert(!(csp1s != sp1d));
-
+
assert(!(csp2d != sp3d));
assert(!(csp2s != sp3s));
assert(!(csp2d != sp3s));
assert( (csp2s != sp4s));
assert( (csp2d != sp4s));
assert( (csp2s != sp4d));
-
+
assert( (csp4d != sp2d));
assert( (csp4s != sp2s));
assert( (csp4d != sp2s));
assert(!(std::span<int>{iArr2} != std::span<float>{fArr2}));
static_assert( (std::span<const int>{iArr1, 9} != std::span<const float>{fArr1, 8}), "");
-}
\ No newline at end of file
+}
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// template<size_t N>
// constexpr span(array<value_type, N>& arr) noexcept;
// template<size_t N>
-// constexpr span(const array<value_type, N>& arr) noexcept;
+// constexpr span(const array<value_type, N>& arr) noexcept;
//
// Remarks: These constructors shall not participate in overload resolution unless:
// — extent == dynamic_extent || N == extent is true, and
{
std::span<int, 2> s1(arr); // expected-error {{no matching constructor for initialization of 'std::span<int, 2>'}}
}
-
+
// Type wrong
{
std::span<float> s1(arr); // expected-error {{no matching constructor for initialization of 'std::span<float>'}}
std::span<float, 3> s2(arr); // expected-error {{no matching constructor for initialization of 'std::span<float, 3>'}}
}
-
+
// CV wrong (dynamically sized)
{
std::span< int> s1{ carr}; // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
};
static_assert(std::size(spans) == 13, "" );
-
+
// No for loops in constexpr land :-(
static_assert(doAssign(spans[0], spans[0]), "");
static_assert(doAssign(spans[0], spans[1]), "");
{carr2 + 1, 2},
{carr3, 2}
};
-
+
static_assert(std::size(spans) == 6, "" );
// No for loops in constexpr land :-(
{arr, arr + 3},
{arr + 1, arr + 3} // same size as s2
};
-
+
for (size_t i = 0; i < std::size(spans); ++i)
for (size_t j = i; j < std::size(spans); ++j)
assert((doAssign(spans[i], spans[j])));
{arr + 1, arr + 3},
{arr + 2, arr + 4}
};
-
+
for (size_t i = 0; i < std::size(spans); ++i)
for (size_t j = i; j < std::size(spans); ++j)
assert((doAssign(spans[i], spans[j])));
{strs + 2, strs + 3},
{strs + 3, strs + 3}
};
-
+
for (size_t i = 0; i < std::size(spans); ++i)
for (size_t j = i; j < std::size(spans); ++j)
assert((doAssign(spans[i], spans[j])));
{strs + 1, strs + 2},
{strs + 2, strs + 3}
};
-
+
for (size_t i = 0; i < std::size(spans); ++i)
for (size_t j = i; j < std::size(spans); ++j)
assert((doAssign(spans[i], spans[j])));
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// Not the same type
{
std::span<float> s1{IsAContainer<int>()}; // expected-error {{no matching constructor for initialization of 'std::span<float>'}}
- std::span<float, 0> s2{IsAContainer<int>()}; // expected-error {{no matching constructor for initialization of 'std::span<float, 0>'}}
+ std::span<float, 0> s2{IsAContainer<int>()}; // expected-error {{no matching constructor for initialization of 'std::span<float, 0>'}}
}
// CV wrong (dynamically sized)
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
int main ()
{
constexpr int carr[] = {1,2,3};
-
+
static_assert(doCopy(std::span< int> ()), "");
static_assert(doCopy(std::span< int,0>()), "");
static_assert(doCopy(std::span<const int> (&carr[0], 1)), "");
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// template<class T, size_t N>
// span(T (&)[N]) -> span<T, N>;
-//
+//
// template<class T, size_t N>
// span(array<T, N>&) -> span<T, N>;
-//
+//
// template<class T, size_t N>
// span(const array<T, N>&) -> span<const T, N>;
-//
+//
// template<class Container>
// span(Container&) -> span<typename Container::value_type>;
-//
+//
// template<class Container>
// span(const Container&) -> span<const typename Container::value_type>;
ASSERT_SAME_TYPE(S, std::span<const long, 5>);
assert((std::equal(std::begin(arr), std::end(arr), s.begin(), s.end())));
}
-
+
{
std::string str{"ABCDE"};
std::span s{str};
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
int main ()
{
std::span<int, 2> s; // expected-error@span:* {{static_assert failed "Can't default construct a statically sized span with size > 0"}}
-
+
// TODO: This is what I want:
// eXpected-error {{no matching constructor for initialization of 'std::span<int, 2>'}}
}
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// constexpr span(pointer ptr, index_type count);
-// Requires: [ptr, ptr + count) shall be a valid range.
+// Requires: [ptr, ptr + count) shall be a valid range.
// If extent is not equal to dynamic_extent, then count shall be equal to extent.
//
std::span<float> s1(arr, 3); // expected-error {{no matching constructor for initialization of 'std::span<float>'}}
std::span<float, 3> s2(arr, 3); // expected-error {{no matching constructor for initialization of 'std::span<float, 3>'}}
}
-
+
// CV wrong (dynamically sized)
{
std::span< int> s1{ carr, 3}; // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// constexpr span(pointer ptr, index_type count);
-// Requires: [ptr, ptr + count) shall be a valid range.
+// Requires: [ptr, ptr + count) shall be a valid range.
// If extent is not equal to dynamic_extent, then count shall be equal to extent.
//
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// constexpr span(pointer first, pointer last);
-// Requires: [first, last) shall be a valid range.
+// Requires: [first, last) shall be a valid range.
// If extent is not equal to dynamic_extent, then last - first shall be equal to extent.
//
std::span<float> s1(arr, arr + 3); // expected-error {{no matching constructor for initialization of 'std::span<float>'}}
std::span<float, 3> s2(arr, arr + 3); // expected-error {{no matching constructor for initialization of 'std::span<float, 3>'}}
}
-
+
// CV wrong (dynamically sized)
{
std::span< int> s1{ carr, carr + 3}; // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// constexpr span(pointer first, pointer last);
-// Requires: [first, last) shall be a valid range.
+// Requires: [first, last) shall be a valid range.
// If extent is not equal to dynamic_extent, then last - first shall be equal to extent.
//
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
std::span<float> s2{sp0}; // expected-error {{no matching constructor for initialization of 'std::span<float>'}}
std::span<float, 0> s3{sp}; // expected-error {{no matching constructor for initialization of 'std::span<float, 0>'}}
std::span<float, 0> s4{sp0}; // expected-error {{no matching constructor for initialization of 'std::span<float, 0>'}}
-
+
checkCV();
}
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// template<size_t N>
// constexpr span(array<value_type, N>& arr) noexcept;
// template<size_t N>
-// constexpr span(const array<value_type, N>& arr) noexcept;
+// constexpr span(const array<value_type, N>& arr) noexcept;
//
// Remarks: These constructors shall not participate in overload resolution unless:
// — extent == dynamic_extent || N == extent is true, and
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
{
_LIBCPP_ASSERT(noexcept(sp[idx]), "");
_LIBCPP_ASSERT(noexcept(sp(idx)), "");
-
+
typename Span::reference r1 = sp[idx];
typename Span::reference r2 = sp(idx);
typename Span::reference r3 = *(sp.data() + idx);
{
_LIBCPP_ASSERT(noexcept(sp[idx]), "");
_LIBCPP_ASSERT(noexcept(sp(idx)), "");
-
+
typename Span::reference r1 = sp[idx];
typename Span::reference r2 = sp(idx);
typename Span::reference r3 = *(sp.data() + idx);
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
assert(spBytes.extent == std::dynamic_extent);
else
assert(spBytes.extent == static_cast<std::ptrdiff_t>(sizeof(typename Span::element_type)) * sp.extent);
-
+
assert((void *) spBytes.data() == (void *) sp.data());
assert(spBytes.size() == sp.size_bytes());
}
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
assert(spBytes.extent == std::dynamic_extent);
else
assert(spBytes.extent == static_cast<std::ptrdiff_t>(sizeof(typename Span::element_type)) * sp.extent);
-
+
assert(static_cast<void*>(spBytes.data()) == static_cast<void*>(sp.data()));
assert(spBytes.size() == sp.size_bytes());
}
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
static_assert(!std::span<const int>(iArr1, 3).empty(), "");
static_assert(!std::span<const int>(iArr1, 4).empty(), "");
static_assert(!std::span<const int>(iArr1, 5).empty(), "");
-
+
assert( (std::span<int>().empty() ));
assert( (std::span<long>().empty() ));
assert( (std::span<double>().empty() ));
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
{
using Sp = std::span<std::string>;
testConstexprSpan<Sp, 0>(Sp{});
-
+
testRuntimeSpan<Sp, 0>(Sp{sarr});
testRuntimeSpan<Sp, 1>(Sp{sarr});
testRuntimeSpan<Sp, 2>(Sp{sarr});
{
using Sp = std::span<std::string, 5>;
-
+
testRuntimeSpan<Sp, 0>(Sp{sarr});
testRuntimeSpan<Sp, 1>(Sp{sarr});
testRuntimeSpan<Sp, 2>(Sp{sarr});
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
{
using Sp = std::span<std::string>;
testConstexprSpan<Sp, 0>(Sp{});
-
+
testRuntimeSpan<Sp, 0>(Sp{sarr});
testRuntimeSpan<Sp, 1>(Sp{sarr});
testRuntimeSpan<Sp, 2>(Sp{sarr});
{
using Sp = std::span<std::string, 5>;
-
+
testRuntimeSpan<Sp, 0>(Sp{sarr});
testRuntimeSpan<Sp, 1>(Sp{sarr});
testRuntimeSpan<Sp, 2>(Sp{sarr});
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// Source Licenses. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
// <span>
// using const_iterator = implementation-defined;
// using reverse_iterator = std::reverse_iterator<iterator>;
// using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-//
+//
// static constexpr index_type extent = Extent;
-//
+//
#include <span>
#include <cassert>
ASSERT_SAME_TYPE(typename S::difference_type, std::ptrdiff_t);
ASSERT_SAME_TYPE(typename S::pointer, ElementType *);
ASSERT_SAME_TYPE(typename S::reference, ElementType &);
-
+
static_assert(S::extent == Size); // check that it exists
testIterator<S, typename S::iterator>();
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-//
+//
// <execution> feature macros
/* Constant Value
typedef std::match_results<const CharT*, Allocator> SM;
SM m0(a);
SM m1(m0);
-
+
assert(m1.size() == m0.size());
assert(m1.str() == m0.str());
assert(m1.get_allocator() == m0.get_allocator());
typedef std::match_results<const CharT*, Allocator> SM;
SM m0(a);
SM m1;
-
+
m1 = m0;
assert(m1.size() == m0.size());
assert(m1.str() == m0.str());
typedef std::match_results<const CharT*, Allocator> SM;
SM m0(a);
SM m1;
-
+
m1 = std::move(m0);
assert(m1.size() == 0);
assert(m1.str() == std::basic_string<CharT>());
// const Allocator& = Allocator())
// -> basic_string<charT, traits, Allocator>;
//
-// A size_type parameter type in a basic_string deduction guide refers to the size_type
+// A size_type parameter type in a basic_string deduction guide refers to the size_type
// member type of the type deduced by the deduction guide.
//
// The deduction guide shall not participate in overload resolution if Allocator
// const Allocator& = Allocator())
// -> basic_string<charT, traits, Allocator>;
//
-// A size_type parameter type in a basic_string deduction guide refers to the size_type
+// A size_type parameter type in a basic_string deduction guide refers to the size_type
// member type of the type deduced by the deduction guide.
//
// The deduction guide shall not participate in overload resolution if Allocator
{
const T modulus = maxValue - minValue + 1;
T ret = rhs + lhs;
- if (ret > maxValue)
+ if (ret > maxValue)
ret -= modulus;
return ret;
}
{
const T modulus = maxValue - minValue + 1;
T ret = lhs - rhs;
- if (ret < minValue)
+ if (ret < minValue)
ret += modulus;
if (ret > maxValue) // this can happen if T is unsigned
ret += modulus;
return ret;
}
-
ASSERT_NOEXCEPT(day{});
ASSERT_NOEXCEPT(day(0U));
ASSERT_NOEXCEPT(static_cast<unsigned>(day(0U)));
-
+
constexpr day d0{};
static_assert(static_cast<unsigned>(d0) == 0, "");
-
+
constexpr day d1{1};
static_assert(static_cast<unsigned>(d1) == 1, "");
-
+
for (unsigned i = 0; i <= 255; ++i)
{
day day(i);
ASSERT_SAME_TYPE(day , decltype( std::declval<day&>()++));
ASSERT_SAME_TYPE(day&, decltype(++std::declval<day&>() ));
-
+
static_assert(testConstexpr<day>(), "");
for (unsigned i = 10; i <= 20; ++i)
ASSERT_SAME_TYPE(day&, decltype(std::declval<day&>() += std::declval<days>()));
ASSERT_SAME_TYPE(day&, decltype(std::declval<day&>() -= std::declval<days>()));
-
+
static_assert(testConstexpr<day, days>(), "");
for (unsigned i = 0; i <= 10; ++i)
AssertComparisons6AreNoexcept<day>();
AssertComparisons6ReturnBool<day>();
-
+
static_assert(testComparisons6Values<day>(0U, 0U), "");
static_assert(testComparisons6Values<day>(0U, 1U), "");
-
+
// Some 'ok' values as well
static_assert(testComparisons6Values<day>( 5U, 5U), "");
static_assert(testComparisons6Values<day>( 5U, 10U), "");
-
+
for (unsigned i = 1; i < 10; ++i)
for (unsigned j = 1; j < 10; ++j)
assert(testComparisons6Values<day>(i, j));
ASSERT_SAME_TYPE(day, decltype(std::declval<day>() - std::declval<days>()));
ASSERT_SAME_TYPE(days, decltype(std::declval<day>() - std::declval<day>()));
-
+
static_assert(testConstexpr<day, days>(), "");
day dy{12};
ASSERT_SAME_TYPE(day, decltype(std::declval<day>() + std::declval<days>()));
ASSERT_SAME_TYPE(day, decltype(std::declval<days>() + std::declval<day>()));
-
+
static_assert(testConstexpr<day, days>(), "");
day dy{12};
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const day& d);
-//
-// Effects: Inserts format(fmt, d) where fmt is "%d" widened to charT.
+//
+// Effects: Inserts format(fmt, d) where fmt is "%d" widened to charT.
// If !d.ok(), appends with " is not a valid day".
-//
+//
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const day& d);
-//
-// Effects: Streams d into os using the format specified by the NTCTS fmt.
+//
+// Effects: Streams d into os using the format specified by the NTCTS fmt.
// fmt encoding follows the rules specified in 25.11.
-//
+//
// template<class charT, class traits, class Alloc = allocator<charT>>
// basic_istream<charT, traits>&
// from_stream(basic_istream<charT, traits>& is, const charT* fmt,
// day& d, basic_string<charT, traits, Alloc>* abbrev = nullptr,
// minutes* offset = nullptr);
-//
+//
// Effects: Attempts to parse the input stream is into the day d using the format flags
-// given in the NTCTS fmt as specified in 25.12.
+// given in the NTCTS fmt as specified in 25.12.
// If the parse fails to decode a valid day, is.setstate(ios_base::failbit)
-// shall be called and d shall not be modified.
+// shall be called and d shall not be modified.
// If %Z is used and successfully parsed, that value will be assigned to *abbrev
// if abbrev is non-null. If %z (or a modified variant) is used and
// successfully parsed, that value will be assigned to *offset if offset is non-null.
-//
+//
#include <chrono>
int main()
{
using day = std::chrono::day;
-
+
static_assert(std::is_trivially_copyable_v<day>, "");
static_assert(std::is_standard_layout_v<day>, "");
}
int main()
{
using last_spec = std::chrono::last_spec;
-
+
ASSERT_SAME_TYPE(const last_spec, decltype(std::chrono::last));
static_assert(std::is_trivially_copyable_v<last_spec>, "");
// constexpr chrono::month month() const noexcept;
// constexpr chrono::day day() const noexcept;
// constexpr bool ok() const noexcept;
-
+
#include <chrono>
#include <type_traits>
#include <cassert>
ASSERT_NOEXCEPT(month_day{});
ASSERT_NOEXCEPT(month_day{month{1}, day{1}});
-
+
constexpr month_day md0{};
static_assert( md0.month() == month{}, "");
static_assert( md0.day() == day{}, "");
// constexpr bool ok() const noexcept;
// Returns: true if m_.ok() is true, 1d <= d_, and d_ is less than or equal to the
-// number of days in month m_; otherwise returns false.
+// number of days in month m_; otherwise returns false.
// When m_ == February, the number of days is considered to be 29.
#include <chrono>
// Returns: x.month() == y.month() && x.day() == y.day().
//
// constexpr bool operator< (const month_day& x, const month_day& y) noexcept;
-// Returns:
-// If x.month() < y.month() returns true.
-// Otherwise, if x.month() > y.month() returns false.
+// Returns:
+// If x.month() < y.month() returns true.
+// Otherwise, if x.month() > y.month() returns false.
// Otherwise, returns x.day() < y.day().
#include <chrono>
AssertComparisons6AreNoexcept<month_day>();
AssertComparisons6ReturnBool<month_day>();
-
+
static_assert( testComparisons6(
- month_day{std::chrono::January, day{1}},
+ month_day{std::chrono::January, day{1}},
month_day{std::chrono::January, day{1}},
true, false), "");
-
+
static_assert( testComparisons6(
- month_day{std::chrono::January, day{1}},
+ month_day{std::chrono::January, day{1}},
month_day{std::chrono::January, day{2}},
false, true), "");
static_assert( testComparisons6(
- month_day{std::chrono::January, day{1}},
+ month_day{std::chrono::January, day{1}},
month_day{std::chrono::February, day{1}},
false, true), "");
for (unsigned i = 1; i < 12; ++i)
for (unsigned j = 1; j < 12; ++j)
assert((testComparisons6(
- month_day{month{i}, day{1}},
- month_day{month{j}, day{1}},
+ month_day{month{i}, day{1}},
+ month_day{month{j}, day{1}},
i == j, i < j )));
-
+
// same month, different days
for (unsigned i = 1; i < 31; ++i)
for (unsigned j = 1; j < 31; ++j)
assert((testComparisons6(
- month_day{month{2}, day{i}},
- month_day{month{2}, day{j}},
+ month_day{month{2}, day{i}},
+ month_day{month{2}, day{j}},
i == j, i < j )));
}
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const month_day& md);
-//
+//
// Returns: os << md.month() << '/' << md.day().
-//
+//
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const month_day& md);
-//
-// Effects: Streams md into os using the format specified by the NTCTS fmt.
+//
+// Effects: Streams md into os using the format specified by the NTCTS fmt.
// fmt encoding follows the rules specified in 25.11.
int main()
{
using month_day = std::chrono::month_day;
-
+
static_assert(std::is_trivially_copyable_v<month_day>, "");
static_assert(std::is_standard_layout_v<month_day>, "");
}
AssertComparisons6AreNoexcept<month_day_last>();
AssertComparisons6ReturnBool<month_day_last>();
-
+
static_assert( testComparisons6Values<month_day_last>(month{1}, month{1}), "");
static_assert( testComparisons6Values<month_day_last>(month{1}, month{2}), "");
//
// constexpr chrono::month month() const noexcept;
// constexpr bool ok() const noexcept;
-
+
#include <chrono>
#include <type_traits>
#include <cassert>
using month_day_last = std::chrono::month_day_last;
ASSERT_NOEXCEPT(month_day_last{month{1}});
-
+
constexpr month_day_last md0{month{}};
static_assert( md0.month() == month{}, "");
static_assert(!md0.ok(), "");
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const month_day_last& mdl);
-//
+//
// Returns: os << mdl.month() << "/last".
int main()
{
using month_day_last = std::chrono::month_day_last;
-
+
static_assert(std::is_trivially_copyable_v<month_day_last>, "");
static_assert(std::is_standard_layout_v<month_day_last>, "");
}
ASSERT_NOEXCEPT(month{});
ASSERT_NOEXCEPT(month(1));
ASSERT_NOEXCEPT(static_cast<unsigned>(month(1)));
-
+
constexpr month m0{};
static_assert(static_cast<unsigned>(m0) == 0, "");
constexpr month m1{1};
static_assert(static_cast<unsigned>(m1) == 1, "");
-
+
for (unsigned i = 0; i <= 255; ++i)
{
month m(i);
int main()
{
using month = std::chrono::month;
-
+
ASSERT_NOEXCEPT(--(std::declval<month&>()) );
ASSERT_NOEXCEPT( (std::declval<month&>())--);
ASSERT_SAME_TYPE(month , decltype( std::declval<month&>()--));
ASSERT_SAME_TYPE(month&, decltype(--std::declval<month&>() ));
-
+
static_assert(testConstexpr<month>(), "");
for (unsigned i = 10; i <= 20; ++i)
ASSERT_SAME_TYPE(month , decltype( std::declval<month&>()++));
ASSERT_SAME_TYPE(month&, decltype(++std::declval<month&>() ));
-
+
static_assert(testConstexpr<month>(), "");
for (unsigned i = 0; i <= 10; ++i)
ASSERT_NOEXCEPT(std::declval<month&>() -= std::declval<months&>());
ASSERT_SAME_TYPE(month&, decltype(std::declval<month&>() += std::declval<months&>()));
ASSERT_SAME_TYPE(month&, decltype(std::declval<month&>() -= std::declval<months&>()));
-
+
static_assert(testConstexpr<month, months>(), "");
for (unsigned i = 1; i <= 10; ++i)
static_assert(testComparisons6Values<month>(0U ,0U), "");
static_assert(testComparisons6Values<month>(0U, 1U), "");
-
+
// Some 'ok' values as well
static_assert(testComparisons6Values<month>( 5U, 5U), "");
static_assert(testComparisons6Values<month>( 5U, 10U), "");
-
+
for (unsigned i = 1; i < 10; ++i)
for (unsigned j = 10; j < 10; ++j)
assert(testComparisons6Values<month>(i, j));
// Returns: x + -y.
//
// constexpr months operator-(const month& x, const month& y) noexcept;
-// Returns: If x.ok() == true and y.ok() == true, returns a value m in the range
-// [months{0}, months{11}] satisfying y + m == x.
-// Otherwise the value returned is unspecified.
+// Returns: If x.ok() == true and y.ok() == true, returns a value m in the range
+// [months{0}, months{11}] satisfying y + m == x.
+// Otherwise the value returned is unspecified.
// [Example: January - February == months{11}. —end example]
extern "C" int printf(const char *, ...);
ASSERT_SAME_TYPE(month , decltype(std::declval<month>() - std::declval<months>()));
ASSERT_SAME_TYPE(months, decltype(std::declval<month>() - std::declval<month> ()));
-
+
static_assert(testConstexpr<month, months>(), "");
month m{6};
// constexpr month operator+(const months& x, const month& y) noexcept;
// Returns:
// month{modulo(static_cast<long long>(int{x}) + (y.count() - 1), 12) + 1}
-// where modulo(n, 12) computes the remainder of n divided by 12 using Euclidean division.
+// where modulo(n, 12) computes the remainder of n divided by 12 using Euclidean division.
// [Note: Given a divisor of 12, Euclidean division truncates towards negative infinity
-// and always produces a remainder in the range of [0, 11].
+// and always produces a remainder in the range of [0, 11].
// Assuming no overflow in the signed summation, this operation results in a month
// holding a value in the range [1, 12] even if !x.ok(). —end note]
// [Example: February + months{11} == January. —end example]
ASSERT_SAME_TYPE(month, decltype(std::declval<month>() + std::declval<months>()));
ASSERT_SAME_TYPE(month, decltype(std::declval<months>() + std::declval<month>() ));
-
+
static_assert(testConstexpr<month, months>(), "");
month my{2};
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const month& m);
-//
-// Effects: If m.ok() == true inserts format(os.getloc(), fmt, m) where fmt is "%b" widened to charT.
+//
+// Effects: If m.ok() == true inserts format(os.getloc(), fmt, m) where fmt is "%b" widened to charT.
// Otherwise inserts int{m} << " is not a valid month".
-//
+//
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const month& m);
-//
-// Effects: Streams m into os using the format specified by the NTCTS fmt.
+//
+// Effects: Streams m into os using the format specified by the NTCTS fmt.
// fmt encoding follows the rules specified in 25.11.
-//
+//
// template<class charT, class traits, class Alloc = allocator<charT>>
// basic_istream<charT, traits>&
// from_stream(basic_istream<charT, traits>& is, const charT* fmt,
// month& m, basic_string<charT, traits, Alloc>* abbrev = nullptr,
// minutes* offset = nullptr);
-//
-// Effects: Attempts to parse the input stream is into the month m using the format flags
+//
+// Effects: Attempts to parse the input stream is into the month m using the format flags
// given in the NTCTS fmt as specified in 25.12. If the parse fails to decode a valid month,
-// is.setstate(ios_- base::failbit) shall be called and m shall not be modified.
-// If %Z is used and successfully parsed, that value will be assigned to *abbrev if
-// abbrev is non-null. If %z (or a modified variant) is used and successfully parsed,
+// is.setstate(ios_- base::failbit) shall be called and m shall not be modified.
+// If %Z is used and successfully parsed, that value will be assigned to *abbrev if
+// abbrev is non-null. If %z (or a modified variant) is used and successfully parsed,
// that value will be assigned to *offset if offset is non-null.
#include <chrono>
int main()
{
using month = std::chrono::month;
-
+
static_assert(std::is_trivially_copyable_v<month>, "");
static_assert(std::is_standard_layout_v<month>, "");
}
// constexpr chrono::month month() const noexcept;
// constexpr chrono::weekday_indexed weekday_indexed() const noexcept;
// constexpr bool ok() const noexcept;
-
+
#include <chrono>
#include <type_traits>
#include <cassert>
using weekday_indexed = std::chrono::weekday_indexed;
ASSERT_NOEXCEPT(month_weekday{month{1}, weekday_indexed{weekday{}, 1}});
-
+
constexpr month_weekday md0{month{}, weekday_indexed{}};
static_assert( md0.month() == month{}, "");
static_assert( md0.weekday_indexed() == weekday_indexed{}, "");
AssertComparisons2AreNoexcept<month_weekday>();
AssertComparisons2ReturnBool<month_weekday>();
-
+
static_assert( testComparisons2(
- month_weekday{std::chrono::January, weekday_indexed{Sunday, 1}},
+ month_weekday{std::chrono::January, weekday_indexed{Sunday, 1}},
month_weekday{std::chrono::January, weekday_indexed{Sunday, 1}},
true), "");
-
+
static_assert( testComparisons2(
month_weekday{std::chrono::January, weekday_indexed{Sunday, 1}},
month_weekday{std::chrono::January, weekday_indexed{Sunday, 2}},
for (unsigned i = 1; i < 12; ++i)
for (unsigned j = 1; j < 12; ++j)
assert((testComparisons2(
- month_weekday{month{i}, weekday_indexed{Sunday, 1}},
- month_weekday{month{j}, weekday_indexed{Sunday, 1}},
+ month_weekday{month{i}, weekday_indexed{Sunday, 1}},
+ month_weekday{month{j}, weekday_indexed{Sunday, 1}},
i == j)));
-
+
// same month, different weeks
for (unsigned i = 1; i < 5; ++i)
for (unsigned j = 1; j < 5; ++j)
assert((testComparisons2(
- month_weekday{month{2}, weekday_indexed{Sunday, i}},
- month_weekday{month{2}, weekday_indexed{Sunday, j}},
+ month_weekday{month{2}, weekday_indexed{Sunday, i}},
+ month_weekday{month{2}, weekday_indexed{Sunday, j}},
i == j)));
// same month, different days
for (unsigned i = 0; i < 6; ++i)
for (unsigned j = 0; j < 6; ++j)
assert((testComparisons2(
- month_weekday{month{2}, weekday_indexed{weekday{i}, 2}},
- month_weekday{month{2}, weekday_indexed{weekday{j}, 2}},
+ month_weekday{month{2}, weekday_indexed{weekday{i}, 2}},
+ month_weekday{month{2}, weekday_indexed{weekday{j}, 2}},
i == j)));
}
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const month_weekday& mwd);
-//
+//
// Returns: os << mwd.month() << '/' << mwd.weekday_indexed().
#include <chrono>
using month = std::chrono::month;
using weekday_indexed = std::chrono::weekday_indexed;
using weekday = std::chrono::weekday;
-
+
std::cout << month_weekday{month{1}, weekday_indexed{weekday{3}, 3}};
}
int main()
{
using month_weekday = std::chrono::month_weekday;
-
+
static_assert(std::is_trivially_copyable_v<month_weekday>, "");
static_assert(std::is_standard_layout_v<month_weekday>, "");
}
// constexpr chrono::month month() const noexcept;
// constexpr chrono::weekday_last weekday_last() const noexcept;
// constexpr bool ok() const noexcept;
-
-
+
+
#include <chrono>
#include <type_traits>
#include <cassert>
constexpr weekday Tuesday = std::chrono::Tuesday;
ASSERT_NOEXCEPT(month_weekday_last{January, weekday_last{Tuesday}});
-
+
// bad month
constexpr month_weekday_last mwdl1{month{}, weekday_last{Tuesday}};
static_assert( mwdl1.month() == month{}, "");
AssertComparisons2ReturnBool<month_weekday_last>();
static_assert( testComparisons2(
- month_weekday_last{std::chrono::January, weekday_last{Tuesday}},
+ month_weekday_last{std::chrono::January, weekday_last{Tuesday}},
month_weekday_last{std::chrono::January, weekday_last{Tuesday}},
true), "");
static_assert( testComparisons2(
- month_weekday_last{std::chrono::January, weekday_last{Tuesday}},
+ month_weekday_last{std::chrono::January, weekday_last{Tuesday}},
month_weekday_last{std::chrono::January, weekday_last{Wednesday}},
false), "");
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const month_weekday_last& mdl);
-//
+//
// Returns: os << mdl.month() << "/last".
using month = std::chrono::month;
using weekday = std::chrono::weekday;
using weekday_last = std::chrono::weekday_last;
-
+
std::cout << month_weekday_last{month{1}, weekday_last{weekday{3}}};
}
int main()
{
using month_weekday_last = std::chrono::month_weekday_last;
-
+
static_assert(std::is_trivially_copyable_v<month_weekday_last>, "");
static_assert(std::is_standard_layout_v<month_weekday_last>, "");
}
// constexpr month_day
// operator/(const month& m, const day& d) noexcept;
// Returns: {m, d}.
-//
+//
// constexpr month_day
// operator/(const day& d, const month& m) noexcept;
// Returns: m / d.
// constexpr month_day
// operator/(const month& m, int d) noexcept;
-// Returns: m / day(d).
-//
+// Returns: m / day(d).
+//
// constexpr month_day
// operator/(int m, const day& d) noexcept;
// Returns: month(m) / d.
-//
+//
// constexpr month_day
// operator/(const day& d, int m) noexcept;
// Returns: month(m) / d.
using day = std::chrono::day;
constexpr month February = std::chrono::February;
-
+
{ // operator/(const month& m, const day& d) (and switched)
ASSERT_NOEXCEPT ( February/day{1});
ASSERT_SAME_TYPE(month_day, decltype(February/day{1}));
// constexpr month_day_last
// operator/(const month& m, last_spec) noexcept;
// Returns: month_day_last{m}.
-//
+//
// constexpr month_day_last
// operator/(int m, last_spec) noexcept;
// Returns: month(m) / last.
-//
+//
// constexpr month_day_last
// operator/(last_spec, const month& m) noexcept;
-// Returns: m / last.
-//
+// Returns: m / last.
+//
// constexpr month_day_last
// operator/(last_spec, int m) noexcept;
// Returns: month(m) / last.
{
using month = std::chrono::month;
using month_day_last = std::chrono::month_day_last;
-
+
constexpr month February = std::chrono::February;
constexpr std::chrono::last_spec last = std::chrono::last;
constexpr auto mdl = February/std::chrono::last;
static_assert(mdl.month() == February, "");
}
-
+
{ // operator/(const month& m, last_spec) and switched
ASSERT_NOEXCEPT ( last/February);
ASSERT_SAME_TYPE(month_day_last, decltype(last/February));
constexpr weekday Tuesday = std::chrono::Tuesday;
constexpr month February = std::chrono::February;
-
+
{ // operator/(const month& m, const weekday_indexed& wdi) (and switched)
ASSERT_NOEXCEPT (February/Tuesday[2]);
ASSERT_SAME_TYPE(month_weekday, decltype(February/Tuesday[2]));
static_assert(wdi.month() == February, "");
static_assert(wdi.weekday_indexed() == Tuesday[3], "");
}
-
+
for (int i = 1; i <= 12; ++i)
for (unsigned j = 0; j <= 6; ++j)
for (unsigned k = 1; k <= 5; ++k)
assert(mwd2.weekday_indexed() == wdi);
assert(mwd1 == mwd2);
}
- }
+ }
{ // operator/(int m, const weekday_indexed& wdi) (and switched)
static_assert(wdi.month() == February, "");
static_assert(wdi.weekday_indexed() == Tuesday[3], "");
}
-
+
for (int i = 1; i <= 12; ++i)
for (unsigned j = 0; j <= 6; ++j)
for (unsigned k = 1; k <= 5; ++k)
assert(mwd2.weekday_indexed() == wdi);
assert(mwd1 == mwd2);
}
- }
+ }
}
// constexpr month_weekday_last
// operator/(const month& m, const weekday_last& wdl) noexcept;
// Returns: {m, wdl}.
-//
+//
// constexpr month_weekday_last
// operator/(int m, const weekday_last& wdl) noexcept;
// Returns: month(m) / wdl.
-//
+//
// constexpr month_weekday_last
// operator/(const weekday_last& wdl, const month& m) noexcept;
// Returns: m / wdl.
-//
+//
// constexpr month_weekday_last
// operator/(const weekday_last& wdl, int m) noexcept;
// Returns: month(m) / wdl.
constexpr weekday Tuesday = std::chrono::Tuesday;
constexpr month February = std::chrono::February;
constexpr std::chrono::last_spec last = std::chrono::last;
-
+
{ // operator/(const month& m, const weekday_last& wdi) (and switched)
ASSERT_NOEXCEPT (February/Tuesday[last]);
ASSERT_SAME_TYPE(month_weekday_last, decltype(February/Tuesday[last]));
static_assert(wdi.month() == February, "");
static_assert(wdi.weekday_last() == Tuesday[last], "");
}
-
+
for (int i = 1; i <= 12; ++i)
for (unsigned j = 0; j <= 6; ++j)
{
static_assert(wdi.month() == February, "");
static_assert(wdi.weekday_indexed() == Tuesday[3], "");
}
-
+
for (int i = 1; i <= 12; ++i)
for (unsigned j = 0; j <= 6; ++j)
{
assert(mwd2.weekday_last() == wdi);
assert(mwd1 == mwd2);
}
- }
+ }
}
// constexpr year_month operator/(const year& y, const month& m) noexcept;
// Returns: {y, m}.
-//
+//
// constexpr year_month operator/(const year& y, int m) noexcept;
// Returns: y / month(m).
static_assert((year{2018}/2).year() == year{2018}, "");
static_assert((year{2018}/2).month() == month{2}, "");
-
+
for (int i = 1000; i <= 1030; ++i)
for (unsigned j = 1; j <= 12; ++j)
{
assert(static_cast<int>(ym.year()) == i);
assert(static_cast<unsigned>(ym.month()) == j);
}
- }
+ }
}
// constexpr year_month_day
// operator/(const year_month& ym, const day& d) noexcept;
// Returns: {ym.year(), ym.month(), d}.
-//
+//
// constexpr year_month_day
// operator/(const year_month& ym, int d) noexcept;
// Returns: ym / day(d).
-//
+//
// constexpr year_month_day
// operator/(const year& y, const month_day& md) noexcept;
// Returns: y / md.month() / md.day().
-//
+//
// constexpr year_month_day
// operator/(int y, const month_day& md) noexcept;
// Returns: year(y) / md.
-//
+//
// constexpr year_month_day
// operator/(const month_day& md, const year& y) noexcept;
// Returns: y / md.
-//
+//
// constexpr year_month_day
// operator/(const month_day& md, int y) noexcept;
// Returns: year(y) / md.
static_assert((Feb2018/day{2}).month() == February, "");
static_assert((Feb2018/day{2}).day() == day{2}, "");
-
+
for (int i = 1000; i < 1010; ++i)
for (int j = 1; j <= 12; ++j)
for (unsigned k = 0; k <= 28; ++k)
static_assert((Feb2018/2).month() == February, "");
static_assert((Feb2018/2).day() == day{2}, "");
-
+
for (int i = 1000; i < 1010; ++i)
for (int j = 1; j <= 12; ++j)
for (unsigned k = 0; k <= 28; ++k)
static_assert((Feb2018/2).month() == February, "");
static_assert((Feb2018/2).day() == day{2}, "");
-
+
for (int i = 1000; i < 1010; ++i)
for (int j = 1; j <= 12; ++j)
for (unsigned k = 0; k <= 28; ++k)
static_assert((year{2018}/month_day{February, day{2}}).day() == day{2}, "" );
static_assert((month_day{February, day{2}}/year{2018}).month() == February, "" );
static_assert((month_day{February, day{2}}/year{2018}).day() == day{2}, "" );
-
+
for (int i = 1000; i < 1010; ++i)
for (int j = 1; j <= 12; ++j)
for (unsigned k = 0; k <= 28; ++k)
static_assert((2018/month_day{February, day{2}}).day() == day{2}, "" );
static_assert((month_day{February, day{2}}/2018).month() == February, "" );
static_assert((month_day{February, day{2}}/2018).day() == day{2}, "" );
-
+
for (int i = 1000; i < 1010; ++i)
for (int j = 1; j <= 12; ++j)
for (unsigned k = 0; k <= 28; ++k)
// constexpr year_month_day_last
// operator/(const year& y, const month_day_last& mdl) noexcept;
// Returns: {y, mdl}.
-//
+//
// constexpr year_month_day_last
// operator/(int y, const month_day_last& mdl) noexcept;
// Returns: year(y) / mdl.
-//
+//
// constexpr year_month_day_last
// operator/(const month_day_last& mdl, const year& y) noexcept;
// Returns: y / mdl.
-//
+//
// constexpr year_month_day_last
// operator/(const month_day_last& mdl, int y) noexcept;
// Returns: year(y) / mdl.
constexpr month February = std::chrono::February;
constexpr std::chrono::last_spec last = std::chrono::last;
-
+
{ // operator/(const year_month& ym, last_spec)
constexpr year_month Feb2018{year{2018}, February};
-
+
ASSERT_NOEXCEPT ( Feb2018/last);
ASSERT_SAME_TYPE(year_month_day_last, decltype(Feb2018/last));
for (int i = 1000; i < 1010; ++i)
for (unsigned j = 1; j <= 12; ++j)
{
- year y{i};
+ year y{i};
month m{j};
year_month_day_last ymdl = year_month{y,m}/last;
assert(ymdl.year() == y);
static_assert((year{2018}/month_day_last{February}).year() == year{2018}, "");
static_assert((month_day_last{February}/year{2018}).month() == February, "");
static_assert((month_day_last{February}/year{2018}).year() == year{2018}, "");
-
+
for (int i = 1000; i < 1010; ++i)
for (unsigned j = 1; j <= 12; ++j)
{
- year y{i};
+ year y{i};
month m{j};
year_month_day_last ymdl1 = y/month_day_last{m};
year_month_day_last ymdl2 = month_day_last{m}/y;
assert(ymdl1.year() == y);
assert(ymdl1 == ymdl2);
}
- }
+ }
{ // operator/(int y, const month_day_last& mdl) (and switched)
ASSERT_NOEXCEPT ( 2018/month_day_last{February});
static_assert((2018/month_day_last{February}).year() == year{2018}, "");
static_assert((month_day_last{February}/2018).month() == February, "");
static_assert((month_day_last{February}/2018).year() == year{2018}, "");
-
+
for (int i = 1000; i < 1010; ++i)
for (unsigned j = 1; j <= 12; ++j)
{
- year y{i};
+ year y{i};
month m{j};
year_month_day_last ymdl1 = i/month_day_last{m};
year_month_day_last ymdl2 = month_day_last{m}/i;
assert(ymdl1.year() == y);
assert(ymdl1 == ymdl2);
}
- }
+ }
}
// constexpr year_month_weekday
// operator/(const year_month& ym, const weekday_indexed& wdi) noexcept;
// Returns: {ym.year(), ym.month(), wdi}.
-//
+//
// constexpr year_month_weekday
// operator/(const year& y, const month_weekday& mwd) noexcept;
// Returns: {y, mwd.month(), mwd.weekday_indexed()}.
-//
+//
// constexpr year_month_weekday
// operator/(int y, const month_weekday& mwd) noexcept;
// Returns: year(y) / mwd.
-//
+//
// constexpr year_month_weekday
// operator/(const month_weekday& mwd, const year& y) noexcept;
// Returns: y / mwd.
-//
+//
// constexpr year_month_weekday
// operator/(const month_weekday& mwd, int y) noexcept;
// Returns: year(y) / mwd.
constexpr weekday Tuesday = std::chrono::Tuesday;
constexpr month February = std::chrono::February;
-
+
{ // operator/(const year_month& ym, const weekday_indexed& wdi)
constexpr year_month Feb2018{year{2018}, February};
-
+
ASSERT_NOEXCEPT ( Feb2018/weekday_indexed{Tuesday, 2});
ASSERT_SAME_TYPE(year_month_weekday, decltype(Feb2018/weekday_indexed{Tuesday, 2}));
assert(ymd2.weekday() == wd);
assert(ymd1 == ymd2);
}
- }
+ }
}
// constexpr year_month_weekday_last
// operator/(const year_month& ym, const weekday_last& wdl) noexcept;
// Returns: {ym.year(), ym.month(), wdl}.
-//
+//
// constexpr year_month_weekday_last
// operator/(const year& y, const month_weekday_last& mwdl) noexcept;
// Returns: {y, mwdl.month(), mwdl.weekday_last()}.
-//
+//
// constexpr year_month_weekday_last
// operator/(int y, const month_weekday_last& mwdl) noexcept;
// Returns: year(y) / mwdl.
-//
+//
// constexpr year_month_weekday_last
// operator/(const month_weekday_last& mwdl, const year& y) noexcept;
// Returns: y / mwdl.
-//
+//
// constexpr year_month_weekday_last
// operator/(const month_weekday_last& mwdl, int y) noexcept;
// Returns: year(y) / mwdl.
constexpr weekday Tuesday = std::chrono::Tuesday;
constexpr month February = std::chrono::February;
-
+
{ // operator/(const year_month& ym, const weekday_last& wdl) (and switched)
constexpr year_month Feb2018{year{2018}, February};
static_assert((Feb2018/weekday_last{Tuesday}).year() == year{2018}, "");
static_assert((Feb2018/weekday_last{Tuesday}).month() == February, "");
static_assert((Feb2018/weekday_last{Tuesday}).weekday() == Tuesday, "");
-
+
for (int i = 1000; i < 1010; ++i)
for (unsigned j = 1; j <= 12; ++j)
for (unsigned k = 0; k <= 6; ++k)
{ // operator/(const year& y, const month_weekday_last& mwdl) (and switched)
constexpr month_weekday_last FebLastTues{February, weekday_last{Tuesday}};
-
+
ASSERT_NOEXCEPT ( year{2018}/FebLastTues);
ASSERT_SAME_TYPE(year_month_weekday_last, decltype(year{2018}/FebLastTues));
ASSERT_NOEXCEPT ( FebLastTues/year{2018});
{ // operator/(int y, const month_weekday_last& mwdl) (and switched)
constexpr month_weekday_last FebLastTues{February, weekday_last{Tuesday}};
-
+
ASSERT_NOEXCEPT ( 2018/FebLastTues);
ASSERT_SAME_TYPE(year_month_weekday_last, decltype(2018/FebLastTues));
ASSERT_NOEXCEPT ( FebLastTues/2018);
// constexpr chrono::weekday weekday() const noexcept;
// constexpr unsigned index() const noexcept;
// constexpr bool ok() const noexcept;
-
+
#include <chrono>
#include <type_traits>
#include <cassert>
ASSERT_NOEXCEPT(weekday_indexed{});
ASSERT_NOEXCEPT(weekday_indexed(weekday{1}, 1));
-
+
constexpr weekday_indexed wdi0{};
static_assert( wdi0.weekday() == weekday{}, "");
static_assert( wdi0.index() == 0, "");
static_assert( wdi1.weekday() == std::chrono::Sunday, "");
static_assert( wdi1.index() == 2, "");
static_assert( wdi1.ok(), "");
-
+
for (unsigned i = 1; i <= 5; ++i)
{
weekday_indexed wdi(std::chrono::Tuesday, i);
AssertComparisons2AreNoexcept<weekday_indexed>();
AssertComparisons2ReturnBool<weekday_indexed>();
-
+
static_assert( (weekday_indexed{} == weekday_indexed{}), "");
static_assert(!(weekday_indexed{} != weekday_indexed{}), "");
static_assert(!(weekday_indexed{} == weekday_indexed{std::chrono::Tuesday, 1}), "");
static_assert( (weekday_indexed{} != weekday_indexed{std::chrono::Tuesday, 1}), "");
-
+
// Some 'ok' values as well
static_assert( (weekday_indexed{weekday{1}, 2} == weekday_indexed{weekday{1}, 2}), "");
static_assert(!(weekday_indexed{weekday{1}, 2} != weekday_indexed{weekday{1}, 2}), "");
// basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const weekday_indexed& wdi);
//
-// Effects: os << wdi.weekday() << '[' << wdi.index().
-// If wdi.index() is in the range [1, 5], appends with ']',
+// Effects: os << wdi.weekday() << '[' << wdi.index().
+// If wdi.index() is in the range [1, 5], appends with ']',
// otherwise appends with " is not a valid index]".
{
using weekday_indexed = std::chrono::weekday_indexed;
using weekday = std::chrono::weekday;
-
+
std::cout << weekday_indexed{weekday{3}};
}
int main()
{
using weekday_indexed = std::chrono::weekday_indexed;
-
+
static_assert(std::is_trivially_copyable_v<weekday_indexed>, "");
static_assert(std::is_standard_layout_v<weekday_indexed>, "");
}
using weekday_last = std::chrono::weekday_last;
ASSERT_NOEXCEPT(weekday_last{weekday{}});
-
+
constexpr weekday_last wdl0{weekday{}};
static_assert( wdl0.weekday() == weekday{}, "");
static_assert( wdl0.ok(), "");
constexpr weekday_last wdl1 {weekday{1}};
static_assert( wdl1.weekday() == weekday{1}, "");
static_assert( wdl1.ok(), "");
-
+
for (unsigned i = 0; i <= 255; ++i)
{
weekday_last wdl{weekday{i}};
AssertComparisons2AreNoexcept<weekday_last>();
AssertComparisons2ReturnBool<weekday_last>();
-
+
static_assert(testComparisons2Values<weekday_last>(weekday{0}, weekday{0}), "");
static_assert(testComparisons2Values<weekday_last>(weekday{0}, weekday{1}), "");
-
+
// Some 'ok' values as well
static_assert(testComparisons2Values<weekday_last>(weekday{2}, weekday{2}), "");
static_assert(testComparisons2Values<weekday_last>(weekday{2}, weekday{3}), "");
-
+
for (unsigned i = 0; i < 6; ++i)
for (unsigned j = 0; j < 6; ++j)
assert(testComparisons2Values<weekday_last>(weekday{i}, weekday{j}));
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const weekday_last& wdl);
-//
+//
// Returns: os << wdl.weekday() << "[last]".
#include <chrono>
{
using weekday_last = std::chrono::weekday_last;
using weekday = std::chrono::weekday;
-
+
std::cout << weekday_last{weekday{3}};
}
int main()
{
using weekday_last = std::chrono::weekday_last;
-
+
static_assert(std::is_trivially_copyable_v<weekday_last>, "");
static_assert(std::is_standard_layout_v<weekday_last>, "");
}
ASSERT_NOEXCEPT(weekday{});
ASSERT_NOEXCEPT(weekday(1));
ASSERT_NOEXCEPT(static_cast<unsigned>(weekday(1)));
-
+
constexpr weekday m0{};
static_assert(static_cast<unsigned>(m0) == 0, "");
constexpr weekday m1{1};
static_assert(static_cast<unsigned>(m1) == 1, "");
-
+
for (unsigned i = 0; i <= 255; ++i)
{
weekday m(i);
ASSERT_SAME_TYPE(weekday , decltype( std::declval<weekday&>()--));
ASSERT_SAME_TYPE(weekday&, decltype(--std::declval<weekday&>() ));
-
+
static_assert(testConstexpr<weekday>(), "");
for (unsigned i = 0; i <= 6; ++i)
ASSERT_SAME_TYPE(weekday , decltype( std::declval<weekday&>()++));
ASSERT_SAME_TYPE(weekday&, decltype(++std::declval<weekday&>() ));
-
+
static_assert(testConstexpr<weekday>(), "");
for (unsigned i = 0; i <= 6; ++i)
// constexpr weekday_indexed operator[](unsigned index) const noexcept;
// constexpr weekday_last operator[](last_spec) const noexcept;
-
-
+
+
#include <chrono>
#include <type_traits>
#include <cassert>
ASSERT_NOEXCEPT( std::declval<weekday>()[std::chrono::last]);
ASSERT_SAME_TYPE(weekday_last, decltype(std::declval<weekday>()[std::chrono::last]));
-
+
static_assert(Sunday[2].weekday() == Sunday, "");
static_assert(Sunday[2].index () == 2, "");
ASSERT_NOEXCEPT( std::declval<weekday&>() -= std::declval<days&>());
ASSERT_SAME_TYPE(weekday&, decltype(std::declval<weekday&>() -= std::declval<days&>()));
-
+
static_assert(testConstexpr<weekday, days>(), "");
for (unsigned i = 0; i <= 6; ++i)
AssertComparisons2AreNoexcept<weekday>();
AssertComparisons2ReturnBool<weekday>();
-
+
static_assert(testComparisons2Values<weekday>(0U ,0U), "");
static_assert(testComparisons2Values<weekday>(0U, 1U), "");
-
+
// Some 'ok' values as well
static_assert(testComparisons2Values<weekday>(5U, 5U), "");
static_assert(testComparisons2Values<weekday>(5U, 2U), "");
-
+
for (unsigned i = 0; i < 6; ++i)
for (unsigned j = 0; j < 6; ++j)
assert(testComparisons2Values<weekday>(i, j));
//
// constexpr days operator-(const weekday& x, const weekday& y) noexcept;
// Returns: If x.ok() == true and y.ok() == true, returns a value d in the range
-// [days{0}, days{6}] satisfying y + d == x.
+// [days{0}, days{6}] satisfying y + d == x.
// Otherwise the value returned is unspecified.
// [Example: Sunday - Monday == days{6}. —end example]
ASSERT_NOEXCEPT( std::declval<weekday>() - std::declval<weekday>());
ASSERT_SAME_TYPE(days, decltype(std::declval<weekday>() - std::declval<weekday>()));
-
+
static_assert(testConstexpr<weekday, days>(), "");
for (unsigned i = 0; i <= 6; ++i)
// constexpr weekday operator+(const weekday& x, const days& y) noexcept;
// Returns:
// weekday{modulo(static_cast<long long>(unsigned{x}) + y.count(), 7)}
-// where modulo(n, 7) computes the remainder of n divided by 7 using Euclidean division.
+// where modulo(n, 7) computes the remainder of n divided by 7 using Euclidean division.
// [Note: Given a divisor of 12, Euclidean division truncates towards negative infinity
-// and always produces a remainder in the range of [0, 6].
+// and always produces a remainder in the range of [0, 6].
// Assuming no overflow in the signed summation, this operation results in a weekday
// holding a value in the range [0, 6] even if !x.ok(). —end note]
// [Example: Monday + days{6} == Sunday. —end example]
ASSERT_NOEXCEPT( std::declval<days>() + std::declval<weekday>());
ASSERT_SAME_TYPE(weekday, decltype(std::declval<days>() + std::declval<weekday>()));
-
+
static_assert(testConstexpr<weekday, days>(), "");
for (unsigned i = 0; i <= 6; ++i)
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const weekday& wd);
-//
-// Effects: If wd.ok() == true inserts format(os.getloc(), fmt, wd) where fmt is "%a" widened to charT.
+//
+// Effects: If wd.ok() == true inserts format(os.getloc(), fmt, wd) where fmt is "%a" widened to charT.
// Otherwise inserts unsigned{wd} << " is not a valid weekday".
-//
+//
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const weekday& wd);
-//
-// Effects: Streams wd into os using the format specified by the NTCTS fmt.
+//
+// Effects: Streams wd into os using the format specified by the NTCTS fmt.
// fmt encoding follows the rules specified in 25.11.
-//
+//
// template<class charT, class traits, class Alloc = allocator<charT>>
// basic_istream<charT, traits>&
// from_stream(basic_istream<charT, traits>& is, const charT* fmt,
// weekday& wd, basic_string<charT, traits, Alloc>* abbrev = nullptr,
// minutes* offset = nullptr);
-//
+//
// Effects: Attempts to parse the input stream is into the weekday wd using
// the format flags given in the NTCTS fmt as specified in 25.12.
// If the parse fails to decode a valid weekday, is.setstate(ios_- base::failbit)
int main()
{
using weekday = std::chrono::weekday;
-
+
std::cout << weekday{3};
}
int main()
{
using weekday = std::chrono::weekday;
-
+
static_assert(std::is_trivially_copyable_v<weekday>, "");
static_assert(std::is_standard_layout_v<weekday>, "");
}
ASSERT_NOEXCEPT(year{});
ASSERT_NOEXCEPT(year(0U));
ASSERT_NOEXCEPT(static_cast<int>(year(0U)));
-
+
constexpr year y0{};
static_assert(static_cast<int>(y0) == 0, "");
constexpr year y1{1};
static_assert(static_cast<int>(y1) == 1, "");
-
+
for (int i = 0; i <= 2550; i += 7)
{
year year(i);
ASSERT_SAME_TYPE(year , decltype( std::declval<year&>()--));
ASSERT_SAME_TYPE(year&, decltype(--std::declval<year&>() ));
-
+
static_assert(testConstexpr<year>(), "");
for (int i = 11000; i <= 11020; ++i)
ASSERT_SAME_TYPE(year , decltype( std::declval<year&>()++));
ASSERT_SAME_TYPE(year&, decltype(++std::declval<year&>() ));
-
+
static_assert(testConstexpr<year>(), "");
for (int i = 11000; i <= 11020; ++i)
ASSERT_SAME_TYPE(year, decltype(+std::declval<year>()));
ASSERT_SAME_TYPE(year, decltype(-std::declval<year>()));
-
+
static_assert(testConstexpr<year>(), "");
for (int i = 10000; i <= 10020; ++i)
ASSERT_SAME_TYPE(year&, decltype(std::declval<year&>() += std::declval<years>()));
ASSERT_SAME_TYPE(year&, decltype(std::declval<year&>() -= std::declval<years>()));
-
+
static_assert(testConstexpr<year, years>(), "");
for (int i = 10000; i <= 10020; ++i)
AssertComparisons6AreNoexcept<year>();
AssertComparisons6ReturnBool<year>();
-
+
static_assert(testComparisons6Values<year>(0,0), "");
static_assert(testComparisons6Values<year>(0,1), "");
-
+
// Some 'ok' values as well
static_assert(testComparisons6Values<year>( 5, 5), "");
static_assert(testComparisons6Values<year>( 5,10), "");
-
+
for (int i = 1; i < 10; ++i)
for (int j = 1; j < 10; ++j)
assert(testComparisons6Values<year>(i, j));
// Returns: x + -y.
//
// constexpr years operator-(const year& x, const year& y) noexcept;
-// Returns: If x.ok() == true and y.ok() == true, returns a value m in the range
-// [years{0}, years{11}] satisfying y + m == x.
-// Otherwise the value returned is unspecified.
+// Returns: If x.ok() == true and y.ok() == true, returns a value m in the range
+// [years{0}, years{11}] satisfying y + m == x.
+// Otherwise the value returned is unspecified.
// [Example: January - February == years{11}. —end example]
extern "C" int printf(const char *, ...);
ASSERT_NOEXCEPT( std::declval<year>() - std::declval<year>());
ASSERT_SAME_TYPE(years, decltype(std::declval<year>() - std::declval<year>()));
-
+
static_assert(testConstexpr<year, years>(), "");
year y{1223};
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const year& y);
-//
-// Effects: Inserts format(fmt, y) where fmt is "%Y" widened to charT.
+//
+// Effects: Inserts format(fmt, y) where fmt is "%Y" widened to charT.
// If !y.ok(), appends with " is not a valid year".
-//
+//
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const year& y);
-//
-// Effects: Streams y into os using the format specified by the NTCTS fmt.
+//
+// Effects: Streams y into os using the format specified by the NTCTS fmt.
// fmt encoding follows the rules specified in 25.11.
-//
+//
// template<class charT, class traits, class Alloc = allocator<charT>>
// basic_istream<charT, traits>&
// from_stream(basic_istream<charT, traits>& is, const charT* fmt,
// year& y, basic_string<charT, traits, Alloc>* abbrev = nullptr,
// minutes* offset = nullptr);
-//
+//
// Effects: Attempts to parse the input stream is into the year y using the format flags
// given in the NTCTS fmt as specified in 25.12. If the parse fails to decode a valid year,
// is.setstate(ios_base::failbit) shall be called and y shall not be modified. If %Z is used
-// and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null.
-// If %z (or a modified variant) is used and successfully parsed, that value will be
+// and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null.
+// If %z (or a modified variant) is used and successfully parsed, that value will be
// assigned to *offset if offset is non-null.
int main()
{
using year = std::chrono::year;
-
+
std::cout << year{2018};
}
int main()
{
using year = std::chrono::year;
-
+
static_assert(std::is_trivially_copyable_v<year>, "");
static_assert(std::is_standard_layout_v<year>, "");
}
ASSERT_NOEXCEPT(year_month{});
ASSERT_NOEXCEPT(year_month{year{1}, month{1}});
-
+
constexpr year_month ym0{};
static_assert( ym0.year() == year{}, "");
static_assert( ym0.month() == month{}, "");
ASSERT_NOEXCEPT( std::declval<year_month&>() -= std::declval<months>());
ASSERT_SAME_TYPE(year_month&, decltype(std::declval<year_month&>() -= std::declval<months>()));
-
+
static_assert(testConstexpr<year_month, months>(year_month{year{1234}, month{1}}), "");
for (unsigned i = 0; i <= 10; ++i)
ASSERT_NOEXCEPT( std::declval<year_month&>() -= std::declval<years>());
ASSERT_SAME_TYPE(year_month&, decltype(std::declval<year_month&>() -= std::declval<years>()));
-
+
static_assert(testConstexpr<year_month, years>(year_month{year{1}, month{1}}), "");
for (int i = 1000; i <= 1010; ++i)
// Returns: x.year() == y.year() && x.month() == y.month().
//
// constexpr bool operator< (const year_month& x, const year_month& y) noexcept;
-// Returns:
-// If x.year() < y.year() returns true.
-// Otherwise, if x.year() > y.year() returns false.
+// Returns:
+// If x.year() < y.year() returns true.
+// Otherwise, if x.year() > y.year() returns false.
// Otherwise, returns x.month() < y.month().
#include <chrono>
AssertComparisons6AreNoexcept<year_month>();
AssertComparisons6ReturnBool<year_month>();
-
+
static_assert( testComparisons6(
- year_month{year{1234}, std::chrono::January},
+ year_month{year{1234}, std::chrono::January},
year_month{year{1234}, std::chrono::January},
true, false), "");
-
+
static_assert( testComparisons6(
- year_month{year{1234}, std::chrono::January},
+ year_month{year{1234}, std::chrono::January},
year_month{year{1234}, std::chrono::February},
false, true), "");
static_assert( testComparisons6(
- year_month{year{1234}, std::chrono::January},
+ year_month{year{1234}, std::chrono::January},
year_month{year{1235}, std::chrono::January},
false, true), "");
for (unsigned i = 1; i < 12; ++i)
for (unsigned j = 1; j < 12; ++j)
assert((testComparisons6(
- year_month{year{1234}, month{i}},
- year_month{year{1234}, month{j}},
+ year_month{year{1234}, month{i}},
+ year_month{year{1234}, month{j}},
i == j, i < j )));
-
+
// same month, different years
for (int i = 1000; i < 20; ++i)
for (int j = 1000; j < 20; ++j)
assert((testComparisons6(
- year_month{year{i}, std::chrono::January},
+ year_month{year{i}, std::chrono::January},
year_month{year{j}, std::chrono::January},
i == j, i < j )));
}
// class year_month;
// constexpr year_month operator-(const year_month& ym, const years& dy) noexcept;
-// Returns: ym + -dy.
-//
+// Returns: ym + -dy.
+//
// constexpr year_month operator-(const year_month& ym, const months& dm) noexcept;
// Returns: ym + -dm.
-//
+//
// constexpr months operator-(const year_month& x, const year_month& y) noexcept;
// Returns: x.year() - y.year() + months{static_cast<int>(unsigned{x.month()}) -
// static_cast<int>(unsigned{y.month()})}
{ // year_month - years
ASSERT_NOEXCEPT( std::declval<year_month>() - std::declval<years>());
ASSERT_SAME_TYPE(year_month, decltype(std::declval<year_month>() - std::declval<years>()));
-
+
// static_assert(testConstexprYears (year_month{year{1}, month{1}}), "");
year_month ym{year{1234}, std::chrono::January};
{ // year_month - months
ASSERT_NOEXCEPT( std::declval<year_month>() - std::declval<months>());
ASSERT_SAME_TYPE(year_month, decltype(std::declval<year_month>() - std::declval<months>()));
-
+
// static_assert(testConstexprMonths(year_month{year{1}, month{1}}), "");
year_month ym{year{1234}, std::chrono::November};
{ // year_month - year_month
ASSERT_NOEXCEPT( std::declval<year_month>() - std::declval<year_month>());
ASSERT_SAME_TYPE(months, decltype(std::declval<year_month>() - std::declval<year_month>()));
-
+
// static_assert(testConstexprMonths(year_month{year{1}, month{1}}), "");
// Same year
// constexpr year_month operator+(const year_month& ym, const years& dy) noexcept;
// Returns: (ym.year() + dy) / ym.month().
-//
+//
// constexpr year_month operator+(const years& dy, const year_month& ym) noexcept;
// Returns: ym + dy.
//
// constexpr year_month operator+(const year_month& ym, const months& dm) noexcept;
-// Returns: A year_month value z such that z - ym == dm.
+// Returns: A year_month value z such that z - ym == dm.
// Complexity: O(1) with respect to the value of dm.
-//
+//
// constexpr year_month operator+(const months& dm, const year_month& ym) noexcept;
// Returns: ym + dm.
ASSERT_SAME_TYPE(year_month, decltype(std::declval<year_month>() + std::declval<years>()));
ASSERT_SAME_TYPE(year_month, decltype(std::declval<years>() + std::declval<year_month>()));
-
+
static_assert(testConstexprYears (year_month{year{1}, month{1}}), "");
year_month ym{year{1234}, std::chrono::January};
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const year_month& ym);
-//
+//
// Returns: os << ym.year() << '/' << ym.month().
-//
-//
+//
+//
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const year_month& ym);
-//
+//
// Effects: Streams ym into os using the format specified by the NTCTS fmt. fmt encoding follows the rules specified in 25.11.
-//
+//
// template<class charT, class traits, class Alloc = allocator<charT>>
// basic_istream<charT, traits>&
// from_stream(basic_istream<charT, traits>& is, const charT* fmt,
// year_month& ym, basic_string<charT, traits, Alloc>* abbrev = nullptr,
// minutes* offset = nullptr);
-//
-// Effects: Attempts to parse the input stream is into the year_month ym using the format
+//
+// Effects: Attempts to parse the input stream is into the year_month ym using the format
// flags given in the NTCTS fmt as specified in 25.12. If the parse fails to decode
// a valid year_month, is.setstate(ios_- base::failbit) shall be called and ym shall
// not be modified. If %Z is used and successfully parsed, that value will be assigned
-// to *abbrev if abbrev is non-null. If %z (or a modified variant) is used and
+// to *abbrev if abbrev is non-null. If %z (or a modified variant) is used and
// successfully parsed, that value will be assigned to *offset if offset is non-null.
using year_month = std::chrono::year_month;
using year = std::chrono::year;
using month = std::chrono::month;
-
+
std::cout << year_month{year{2018}, month{3}};
}
int main()
{
using year_month = std::chrono::year_month;
-
+
static_assert(std::is_trivially_copyable_v<year_month>, "");
static_assert(std::is_standard_layout_v<year_month>, "");
}
// explicit constexpr year_month_day(const local_days& dp) noexcept;
//
//
-// Effects: Constructs an object of type year_month_day that corresponds
+// Effects: Constructs an object of type year_month_day that corresponds
// to the date represented by dp
//
// Remarks: Equivalent to constructing with sys_days{dp.time_since_epoch()}.
ASSERT_NOEXCEPT(year_month_day{});
ASSERT_NOEXCEPT(year_month_day{year{1}, month{1}, day{1}});
-
+
constexpr month January = std::chrono::January;
-
+
constexpr year_month_day ym0{};
static_assert( ym0.year() == year{}, "");
static_assert( ym0.month() == month{}, "");
// constexpr year_month_day(const sys_days& dp) noexcept;
//
-// Effects: Constructs an object of type year_month_day that corresponds
+// Effects: Constructs an object of type year_month_day that corresponds
// to the date represented by dp
//
-// Remarks: For any value ymd of type year_month_day for which ymd.ok() is true,
+// Remarks: For any value ymd of type year_month_day for which ymd.ok() is true,
// ymd == year_month_day{sys_days{ymd}} is true.
//
// constexpr chrono::year year() const noexcept;
// ASSERT_NOEXCEPT(year_month_day{std::declval<const year_month_day_last>()});
assert(false);
-
+
}
ASSERT_SAME_TYPE(year_month_day&, decltype(std::declval<year_month_day&>() += std::declval<months>()));
ASSERT_SAME_TYPE(year_month_day&, decltype(std::declval<year_month_day&>() -= std::declval<months>()));
-
+
static_assert(testConstexpr<year_month_day, months>(year_month_day{year{1234}, month{1}, day{1}}), "");
for (unsigned i = 0; i <= 10; ++i)
ASSERT_SAME_TYPE(year_month_day&, decltype(std::declval<year_month_day&>() += std::declval<years>()));
ASSERT_SAME_TYPE(year_month_day&, decltype(std::declval<year_month_day&>() -= std::declval<years>()));
-
+
static_assert(testConstexpr<year_month_day, years>(year_month_day{year{1}, month{1}, day{1}}), "");
for (int i = 1000; i <= 1010; ++i)
// Returns: x.year() == y.year() && x.month() == y.month().
//
// constexpr bool operator< (const year_month_day& x, const year_month_day& y) noexcept;
-// Returns:
-// If x.year() < y.year() returns true.
-// Otherwise, if x.year() > y.year() returns false.
+// Returns:
+// If x.year() < y.year() returns true.
+// Otherwise, if x.year() > y.year() returns false.
// Otherwise, if x.month() < y.month() returns true.
// Otherwise, if x.month() > y.month() returns false.
// Otherwise, returns x.day() < y.day()
AssertComparisons6AreNoexcept<year_month_day>();
AssertComparisons6ReturnBool<year_month_day>();
-
+
constexpr month January = std::chrono::January;
constexpr month February = std::chrono::February;
static_assert( testComparisons6(
- year_month_day{year{1234}, January, day{1}},
+ year_month_day{year{1234}, January, day{1}},
year_month_day{year{1234}, January, day{1}},
true, false), "");
-
+
// different day
static_assert( testComparisons6(
- year_month_day{year{1234}, January, day{1}},
+ year_month_day{year{1234}, January, day{1}},
year_month_day{year{1234}, January, day{2}},
false, true), "");
-
+
// different month
static_assert( testComparisons6(
year_month_day{year{1234}, January, day{1}},
for (unsigned i = 1; i < 28; ++i)
for (unsigned j = 1; j < 28; ++j)
assert((testComparisons6(
- year_month_day{year{1234}, January, day{i}},
- year_month_day{year{1234}, January, day{j}},
+ year_month_day{year{1234}, January, day{i}},
+ year_month_day{year{1234}, January, day{j}},
i == j, i < j )));
-
+
// same year, different months
for (unsigned i = 1; i < 12; ++i)
for (unsigned j = 1; j < 12; ++j)
assert((testComparisons6(
- year_month_day{year{1234}, month{i}, day{12}},
- year_month_day{year{1234}, month{j}, day{12}},
+ year_month_day{year{1234}, month{i}, day{12}},
+ year_month_day{year{1234}, month{j}, day{12}},
i == j, i < j )));
-
+
// same month, different years
for (int i = 1000; i < 20; ++i)
for (int j = 1000; j < 20; ++j)
assert((testComparisons6(
- year_month_day{year{i}, January, day{12}},
+ year_month_day{year{i}, January, day{12}},
year_month_day{year{j}, January, day{12}},
i == j, i < j )));
}
// class year_month_day;
// constexpr year_month_day operator-(const year_month_day& ymd, const years& dy) noexcept;
-// Returns: ymd + (-dy)
+// Returns: ymd + (-dy)
#include <chrono>
constexpr month January = std::chrono::January;
static_assert(test_constexpr(), "");
-
+
year_month_day ym{year{1234}, January, day{10}};
for (int i = 0; i <= 10; ++i)
{
// constexpr year_month_day operator+(const year_month_day& ymd, const months& dm) noexcept;
// Returns: (ymd.year() / ymd.month() + dm) / ymd.day().
-//
+//
// constexpr year_month_day operator+(const months& dm, const year_month_day& ymd) noexcept;
// Returns: ymd + dm.
//
//
// constexpr year_month_day operator+(const year_month_day& ymd, const years& dy) noexcept;
// Returns: (ymd.year() + dy) / ymd.month() / ymd.day().
-//
+//
// constexpr year_month_day operator+(const years& dy, const year_month_day& ymd) noexcept;
// Returns: ym + dm.
ASSERT_SAME_TYPE(year_month_day, decltype(std::declval<year_month_day>() + std::declval<years>()));
ASSERT_SAME_TYPE(year_month_day, decltype(std::declval<years>() + std::declval<year_month_day>()));
-
+
static_assert(testConstexprYears (year_month_day{year{1}, month{1}, day{1}}), "");
year_month_day ym{year{1234}, std::chrono::January, day{12}};
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const year_month_day& ym);
-//
+//
// Returns: os << ym.year() << '/' << ym.month().
-//
-//
+//
+//
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const year_month_day& ym);
-//
+//
// Effects: Streams ym into os using the format specified by the NTCTS fmt. fmt encoding follows the rules specified in 25.11.
-//
+//
// template<class charT, class traits, class Alloc = allocator<charT>>
// basic_istream<charT, traits>&
// from_stream(basic_istream<charT, traits>& is, const charT* fmt,
// year_month_day& ym, basic_string<charT, traits, Alloc>* abbrev = nullptr,
// minutes* offset = nullptr);
-//
-// Effects: Attempts to parse the input stream is into the year_month_day ym using the format
+//
+// Effects: Attempts to parse the input stream is into the year_month_day ym using the format
// flags given in the NTCTS fmt as specified in 25.12. If the parse fails to decode
// a valid year_month_day, is.setstate(ios_- base::failbit) shall be called and ym shall
// not be modified. If %Z is used and successfully parsed, that value will be assigned
-// to *abbrev if abbrev is non-null. If %z (or a modified variant) is used and
+// to *abbrev if abbrev is non-null. If %z (or a modified variant) is used and
// successfully parsed, that value will be assigned to *offset if offset is non-null.
using year = std::chrono::year;
using month = std::chrono::month;
using day = std::chrono::day;
-
+
std::cout << year_month_day{year{2018}, month{3}, day{12}};
}
int main()
{
using year_month_day = std::chrono::year_month_day;
-
+
static_assert(std::is_trivially_copyable_v<year_month_day>, "");
static_assert(std::is_standard_layout_v<year_month_day>, "");
}
using year_month_day_last = std::chrono::year_month_day_last;
ASSERT_NOEXCEPT(year_month_day_last{year{1}, month_day_last{month{1}}});
-
+
constexpr month January = std::chrono::January;
constexpr year_month_day_last ymdl0{year{}, month_day_last{month{}}};
static_assert( ymdl0.month() == month{}, "");
static_assert( ymdl0.month_day_last() == month_day_last{month{}}, "");
static_assert(!ymdl0.ok(), "");
-
+
constexpr year_month_day_last ymdl1{year{2019}, month_day_last{January}};
static_assert( ymdl1.year() == year{2019}, "");
static_assert( ymdl1.month() == January, "");
// TODO: wait for calendar
// ASSERT_NOEXCEPT( std::declval<const year_month_day_last>().day());
// ASSERT_SAME_TYPE(day, decltype(std::declval<const year_month_day_last>().day()));
-//
+//
// static_assert( year_month_day_last{}.day() == day{}, "");
for (unsigned i = 1; i <= 12; ++i)
ASSERT_SAME_TYPE(year_month_day_last&, decltype(std::declval<year_month_day_last&>() += std::declval<months>()));
ASSERT_SAME_TYPE(year_month_day_last&, decltype(std::declval<year_month_day_last&>() -= std::declval<months>()));
-
+
static_assert(testConstexpr<year_month_day_last, months>(year_month_day_last{year{1234}, month_day_last{month{1}}}), "");
for (unsigned i = 0; i <= 10; ++i)
ASSERT_SAME_TYPE(year_month_day_last&, decltype(std::declval<year_month_day_last&>() += std::declval<years>()));
ASSERT_SAME_TYPE(year_month_day_last&, decltype(std::declval<year_month_day_last&>() -= std::declval<years>()));
-
+
static_assert(testConstexpr<year_month_day_last, years>(year_month_day_last{year{1}, month_day_last{month{1}}}), "");
for (int i = 1000; i <= 1010; ++i)
// Returns: x.year() == y.year() && x.month_day_last() == y.month_day_last().
//
// constexpr bool operator< (const year_month_day_last& x, const year_month_day_last& y) noexcept;
-// Returns:
-// If x.year() < y.year(), returns true.
+// Returns:
+// If x.year() < y.year(), returns true.
// Otherwise, if x.year() > y.year(), returns false.
// Otherwise, returns x.month_day_last() < y.month_day_last()
AssertComparisons6AreNoexcept<year_month_day_last>();
AssertComparisons6ReturnBool<year_month_day_last>();
-
+
constexpr month January = std::chrono::January;
constexpr month February = std::chrono::February;
static_assert( testComparisons6(
- year_month_day_last{year{1234}, month_day_last{January}},
+ year_month_day_last{year{1234}, month_day_last{January}},
year_month_day_last{year{1234}, month_day_last{January}},
true, false), "");
-
+
// different month
static_assert( testComparisons6(
year_month_day_last{year{1234}, month_day_last{January}},
for (unsigned i = 1; i < 12; ++i)
for (unsigned j = 1; j < 12; ++j)
assert((testComparisons6(
- year_month_day_last{year{1234}, month_day_last{month{i}}},
- year_month_day_last{year{1234}, month_day_last{month{j}}},
+ year_month_day_last{year{1234}, month_day_last{month{i}}},
+ year_month_day_last{year{1234}, month_day_last{month{j}}},
i == j, i < j )));
-
+
// same month, different years
for (int i = 1000; i < 20; ++i)
for (int j = 1000; j < 20; ++j)
assert((testComparisons6(
- year_month_day_last{year{i}, month_day_last{January}},
+ year_month_day_last{year{i}, month_day_last{January}},
year_month_day_last{year{j}, month_day_last{January}},
i == j, i < j )));
}
// constexpr year_month_day_last
// operator-(const year_month_day_last& ymdl, const months& dm) noexcept;
-//
+//
// Returns: ymdl + (-dm).
//
// constexpr year_month_day_last
// operator-(const year_month_day_last& ymdl, const years& dy) noexcept;
-//
+//
// Returns: ymdl + (-dy).
// operator+(const year_month_day_last& ymdl, const months& dm) noexcept;
//
// Returns: (ymdl.year() / ymdl.month() + dm) / last.
-//
+//
// constexpr year_month_day_last
// operator+(const months& dm, const year_month_day_last& ymdl) noexcept;
//
// Returns: ymdl + dm.
//
//
-// constexpr year_month_day_last
+// constexpr year_month_day_last
// operator+(const year_month_day_last& ymdl, const years& dy) noexcept;
//
// Returns: {ymdl.year()+dy, ymdl.month_day_last()}.
-//
+//
// constexpr year_month_day_last
// operator+(const years& dy, const year_month_day_last& ymdl) noexcept;
//
-// Returns: ymdl + dy
+// Returns: ymdl + dy
ASSERT_SAME_TYPE(year_month_day_last, decltype(std::declval<year_month_day_last>() + std::declval<years>()));
ASSERT_SAME_TYPE(year_month_day_last, decltype(std::declval<years>() + std::declval<year_month_day_last>()));
-
+
static_assert(testConstexprYears(year_month_day_last{year{1}, month_day_last{January}}), "");
year_month_day_last ym{year{1234}, month_day_last{January}};
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const year_month_day_last& ymdl);
-//
+//
// Returns: os << ymdl.year() << '/' << ymdl.month_day_last().
// explicit constexpr year_month_weekday(const local_days& dp) noexcept;
//
//
-// Effects: Constructs an object of type year_month_weekday that corresponds
+// Effects: Constructs an object of type year_month_weekday that corresponds
// to the date represented by dp
//
// Remarks: Equivalent to constructing with sys_days{dp.time_since_epoch()}.
ASSERT_NOEXCEPT(year_month_weekday{});
ASSERT_NOEXCEPT(year_month_weekday{year{1}, month{1}, weekday_indexed{Tuesday, 1}});
-
+
constexpr year_month_weekday ym0{};
static_assert( ym0.year() == year{}, "");
static_assert( ym0.month() == month{}, "");
// constexpr year_month_weekday(const sys_days& dp) noexcept;
//
-// Effects: Constructs an object of type year_month_weekday that corresponds
+// Effects: Constructs an object of type year_month_weekday that corresponds
// to the date represented by dp
//
-// Remarks: For any value ymd of type year_month_weekday for which ymd.ok() is true,
+// Remarks: For any value ymd of type year_month_weekday for which ymd.ok() is true,
// ymd == year_month_weekday{sys_days{ymd}} is true.
//
// constexpr chrono::year year() const noexcept;
ASSERT_NOEXCEPT( std::declval<year_month_weekday&>() -= std::declval<years>());
ASSERT_SAME_TYPE(year_month_weekday&, decltype(std::declval<year_month_weekday&>() -= std::declval<years>()));
-
+
constexpr weekday Tuesday = std::chrono::Tuesday;
constexpr month January = std::chrono::January;
AssertComparisons2AreNoexcept<year_month_weekday>();
AssertComparisons2ReturnBool<year_month_weekday>();
-
+
constexpr month January = std::chrono::January;
constexpr month February = std::chrono::February;
constexpr weekday Tuesday = std::chrono::Tuesday;
static_assert( testComparisons2(
- year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, 1}},
+ year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, 1}},
year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, 1}},
true), "");
-
+
// different day
static_assert( testComparisons2(
- year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, 1}},
+ year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, 1}},
year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, 2}},
false), "");
-
+
// different month
static_assert( testComparisons2(
year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, 1}},
year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, i}},
year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, j}},
i == j)));
-
+
// same year, different months
for (unsigned i = 1; i < 12; ++i)
for (unsigned j = 1; j < 12; ++j)
year_month_weekday{year{1234}, month{i}, weekday_indexed{Tuesday, 1}},
year_month_weekday{year{1234}, month{j}, weekday_indexed{Tuesday, 1}},
i == j)));
-
+
// same month, different years
for (int i = 1000; i < 20; ++i)
for (int j = 1000; j < 20; ++j)
// constexpr year_month_weekday operator-(const year_month_weekday& ymwd, const months& dm) noexcept;
// Returns: ymwd + (-dm).
-//
+//
// constexpr year_month_weekday operator-(const year_month_weekday& ymwd, const years& dy) noexcept;
// Returns: ymwd + (-dy).
ASSERT_SAME_TYPE(year_month_weekday, decltype(std::declval<year_month_weekday>() - std::declval<years>()));
static_assert(testConstexprYears(), "");
-
+
year_month_weekday ym{year{1234}, November, weekday_indexed{Tuesday, 1}};
for (int i = 0; i <= 10; ++i)
{
assert(ym1.index() == 1);
}
}
-
+
{ // year_month_weekday - months
ASSERT_NOEXCEPT( std::declval<year_month_weekday>() - std::declval<months>());
ASSERT_SAME_TYPE(year_month_weekday, decltype(std::declval<year_month_weekday>() - std::declval<months>()));
static_assert(testConstexprMonths(), "");
-
+
year_month_weekday ym{year{1234}, November, weekday_indexed{Tuesday, 2}};
for (unsigned i = 1; i <= 10; ++i)
{
// constexpr year_month_weekday operator+(const year_month_weekday& ymd, const months& dm) noexcept;
// Returns: (ymd.year() / ymd.month() + dm) / ymd.day().
-//
+//
// constexpr year_month_weekday operator+(const months& dm, const year_month_weekday& ymd) noexcept;
// Returns: ymd + dm.
//
//
// constexpr year_month_weekday operator+(const year_month_weekday& ymd, const years& dy) noexcept;
// Returns: (ymd.year() + dy) / ymd.month() / ymd.day().
-//
+//
// constexpr year_month_weekday operator+(const years& dy, const year_month_weekday& ymd) noexcept;
// Returns: ym + dm.
ASSERT_SAME_TYPE(year_month_weekday, decltype(std::declval<year_month_weekday>() + std::declval<years>()));
ASSERT_SAME_TYPE(year_month_weekday, decltype(std::declval<years>() + std::declval<year_month_weekday>()));
-
+
static_assert(testConstexprYears (year_month_weekday{year{1}, January, weekday_indexed{Tuesday, 1}}), "");
year_month_weekday ym{year{1234}, std::chrono::January, weekday_indexed{Tuesday, 3}};
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const year_month_weekday& ym);
-//
+//
// Returns: os << ym.year() << '/' << ym.month().
-//
-//
+//
+//
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const year_month_weekday& ym);
-//
+//
// Effects: Streams ym into os using the format specified by the NTCTS fmt. fmt encoding follows the rules specified in 25.11.
-//
+//
// template<class charT, class traits, class Alloc = allocator<charT>>
// basic_istream<charT, traits>&
// from_stream(basic_istream<charT, traits>& is, const charT* fmt,
// year_month_weekday& ym, basic_string<charT, traits, Alloc>* abbrev = nullptr,
// minutes* offset = nullptr);
-//
-// Effects: Attempts to parse the input stream is into the year_month_weekday ym using the format
+//
+// Effects: Attempts to parse the input stream is into the year_month_weekday ym using the format
// flags given in the NTCTS fmt as specified in 25.12. If the parse fails to decode
// a valid year_month_weekday, is.setstate(ios_- base::failbit) shall be called and ym shall
// not be modified. If %Z is used and successfully parsed, that value will be assigned
-// to *abbrev if abbrev is non-null. If %z (or a modified variant) is used and
+// to *abbrev if abbrev is non-null. If %z (or a modified variant) is used and
// successfully parsed, that value will be assigned to *offset if offset is non-null.
using year = std::chrono::year;
using month = std::chrono::month;
using weekday = std::chrono::weekday;
-
+
std::cout << year_month_weekday{year{2018}, month{3}, weekday{4}};
}
int main()
{
using year_month_weekday = std::chrono::year_month_weekday;
-
+
static_assert(std::is_trivially_copyable_v<year_month_weekday>, "");
static_assert(std::is_standard_layout_v<year_month_weekday>, "");
}
constexpr weekday Tuesday = std::chrono::Tuesday;
ASSERT_NOEXCEPT(year_month_weekday_last{year{1}, month{1}, weekday_last{Tuesday}});
-
+
constexpr year_month_weekday_last ym1{year{2019}, January, weekday_last{Tuesday}};
static_assert( ym1.year() == year{2019}, "");
static_assert( ym1.month() == January, "");
ASSERT_SAME_TYPE(year_month_weekday_last&, decltype(std::declval<year_month_weekday_last&>() += std::declval<years>()));
ASSERT_SAME_TYPE(year_month_weekday_last&, decltype(std::declval<year_month_weekday_last&>() -= std::declval<years>()));
-
+
constexpr weekday Tuesday = std::chrono::Tuesday;
constexpr month January = std::chrono::January;
AssertComparisons2AreNoexcept<year_month_weekday_last>();
AssertComparisons2ReturnBool<year_month_weekday_last>();
-
+
constexpr month January = std::chrono::January;
constexpr month February = std::chrono::February;
constexpr weekday Tuesday = std::chrono::Tuesday;
constexpr weekday Wednesday = std::chrono::Wednesday;
static_assert( testComparisons2(
- year_month_weekday_last{year{1234}, January, weekday_last{Tuesday}},
+ year_month_weekday_last{year{1234}, January, weekday_last{Tuesday}},
year_month_weekday_last{year{1234}, January, weekday_last{Tuesday}},
true), "");
-
+
// different day
static_assert( testComparisons2(
- year_month_weekday_last{year{1234}, January, weekday_last{Tuesday}},
+ year_month_weekday_last{year{1234}, January, weekday_last{Tuesday}},
year_month_weekday_last{year{1234}, January, weekday_last{Wednesday}},
false), "");
-
+
// different month
static_assert( testComparisons2(
year_month_weekday_last{year{1234}, January, weekday_last{Tuesday}},
year_month_weekday_last{year{1234}, January, weekday_last{weekday{i}}},
year_month_weekday_last{year{1234}, January, weekday_last{weekday{j}}},
i == j)));
-
+
// same year, different months
for (unsigned i = 1; i < 12; ++i)
for (unsigned j = 1; j < 12; ++j)
year_month_weekday_last{year{1234}, month{i}, weekday_last{Tuesday}},
year_month_weekday_last{year{1234}, month{j}, weekday_last{Tuesday}},
i == j)));
-
+
// same month, different years
for (int i = 1000; i < 20; ++i)
for (int j = 1000; j < 20; ++j)
// constexpr year_month_weekday_last operator-(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
// Returns: ymwdl + (-dm).
-//
+//
// constexpr year_month_weekday_last operator-(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
// Returns: ymwdl + (-dy).
assert(ym1.weekday_last() == weekday_last{Tuesday});
}
}
-
+
{ // year_month_weekday_last - months
ASSERT_NOEXCEPT( std::declval<year_month_weekday_last>() - std::declval<months>());
assert(ym1.weekday_last() == weekday_last{Tuesday});
}
}
-
+
}
// constexpr year_month_weekday_last operator+(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
// Returns: (ymwdl.year() / ymwdl.month() + dm) / ymwdl.weekday_last().
-//
+//
// constexpr year_month_weekday_last operator+(const months& dm, const year_month_weekday_last& ymwdl) noexcept;
// Returns: ymwdl + dm.
-//
+//
// constexpr year_month_weekday_last operator+(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
// Returns: {ymwdl.year()+dy, ymwdl.month(), ymwdl.weekday_last()}.
-//
+//
// constexpr year_month_weekday_last operator+(const years& dy, const year_month_weekday_last& ymwdl) noexcept;
// Returns: ymwdl + dy.
ASSERT_SAME_TYPE(year_month_weekday_last, decltype(std::declval<year_month_weekday_last>() + std::declval<years>()));
ASSERT_SAME_TYPE(year_month_weekday_last, decltype(std::declval<years>() + std::declval<year_month_weekday_last>()));
-
+
static_assert(testConstexprYears (year_month_weekday_last{year{1}, January, weekday_last{Tuesday}}), "");
year_month_weekday_last ym{year{1234}, std::chrono::January, weekday_last{Tuesday}};
// template<class charT, class traits>
// basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os, const year_month_weekday_last& ymwdl);
-//
+//
// Returns: os << ymwdl.year() << '/' << ymwdl.month() << '/' << ymwdl.weekday_last().
using month = std::chrono::month;
using weekday = std::chrono::weekday;
using weekday_last = std::chrono::weekday_last;
-
+
std::cout << year_month_weekday_last{year{2018}, month{3}, weekday_last{weekday{4}}};
}
int main()
{
using year_month_weekday_last = std::chrono::year_month_weekday_last;
-
+
static_assert(std::is_trivially_copyable_v<year_month_weekday_last>, "");
static_assert(std::is_standard_layout_v<year_month_weekday_last>, "");
}
t += Duration(2);
assert(t.time_since_epoch() == Duration(5));
}
-
+
#if TEST_STD_VER > 14
static_assert(constexpr_test(), "");
#endif
t -= Duration(2);
assert(t.time_since_epoch() == Duration(1));
}
-
+
#if TEST_STD_VER > 14
static_assert(constexpr_test(), "");
#endif
{
const bool isEqual = val1 == val2;
const bool isLess = val1 < val2;
-
+
return testComparisons6(T(val1), T(val2), isEqual, isLess);
}
TEST_CONSTEXPR_CXX14 bool testComparisons2Values(Param val1, Param val2)
{
const bool isEqual = val1 == val2;
-
+
return testComparisons2(T(val1), T(val2), isEqual);
}
projects / platform / upstream / llvm.git / commitdiff