This is an archive of the discontinued LLVM Phabricator instance.

Differential D103273

[libc++] Update all the pre-defined iterator types for C++20
ClosedPublic

Authored by ldionne on May 27 2021, 11:23 AM.

Details

Reviewers
Mordante
zoecarver
Group Reviewers
Restricted Project
Commits
rG41bdf64d3e94: [libc++] Update all the pre-defined iterator types for C++20
Summary

Make sure we provide the correct It::difference_type member and update
the tests and synopses to be accurate.

Supersedes D102657 and D103101 (thanks to the original authors).

Diff Detail

Event Timeline

ldionne requested review of this revision.May 27 2021, 11:23 AM
ldionne created this revision.
Herald added a project: Restricted Project. · View Herald TranscriptMay 27 2021, 11:23 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Mordante requested changes to this revision.May 27 2021, 12:04 PM
Mordante added a subscriber: Mordante.

Thanks a lot for working on this! After this has landed I can remove some work-arounds from my <format> branch.

libcxx/include/iterator
253

std::ptrdiff_t -> ptrdiff_t here and other places.

280–281

I miss constexpr front_insert_iterator() noexcept = default; // since C++20 and the implementation.
back_insert_iterator has the same issue.

305–306

I miss insert_iterator() = default; // since C++20 and the implementation. (This one has no constexpr nor noexcept.)

392–400

Remove std:: here and similar places.

This revision now requires changes to proceed.May 27 2021, 12:04 PM
Harbormaster completed remote builds in B106565: Diff 348340.May 27 2021, 1:52 PM
zoecarver accepted this revision as: zoecarver.May 27 2021, 2:54 PM

LGTM

ldionne updated this revision to Diff 348506.May 28 2021, 6:04 AM
ldionne marked 4 inline comments as done.

Address review comments.

ldionne added a subscriber: tcanens.May 28 2021, 6:05 AM
ldionne added inline comments.
libcxx/include/iterator
280–281

Good catch, somehow I missed those. Thanks.

502

@tcanens I think this one is missing from cppreference: https://en.cppreference.com/w/cpp/iterator/ostreambuf_iterator/ostreambuf_iterator

• Quuxplusone added inline comments.May 28 2021, 6:21 AM
libcxx/include/iterator
502

It'll be DRed out of existence by p2325r3, so I bet it's not worth fixing on cppreference.
(See my LWG reflector thread of last week, "Must ostreambuf_iterator<char>().failed() == false?".)
There's an executive design decision to be made here as to whether we should just go ahead and implement p2325 (although it seems like both me and Louis have relatively independently made decisions to implement not-p2325). Either p2325 or not-p2325 would suffice to unblock @Mordante AIUI.

899

I strongly recommend removing the redundant constexpr and noexcept, for cleanliness' sake. (Defaulted functions are always constexpr-auto and noexcept-auto.)
Ditto line 908, 1075, 1200; already OK on line 954.

libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp
58

Nice! :)

Harbormaster completed remote builds in B106696: Diff 348506.May 28 2021, 9:32 AM
Mordante accepted this revision as: Mordante.May 28 2021, 9:35 AM

LGTM! I'll leave the final approval for @Quuxplusone.

libcxx/include/iterator
502

Yeah when P2325 is applied the default constructors will be removed, but an output_iterator should no longer require default_constructible. For <format> I only need the back_insert_iterator to be an output_iterator.

899

I've no strong opinion about this, but I slight prefer to use the wording the standard provides. Thus including constexpr and noexept.

ldionne accepted this revision as: Restricted Project.May 31 2021, 8:57 AM
ldionne marked 3 inline comments as done.
ldionne added inline comments.
libcxx/include/iterator
899

Same as @Mordante , which is why I did it that way.

This revision is now accepted and ready to land.May 31 2021, 8:57 AM
Closed by commit rG41bdf64d3e94: [libc++] Update all the pre-defined iterator types for C++20 (authored by ldionne). · Explain WhyMay 31 2021, 8:57 AM
This revision was automatically updated to reflect the committed changes.
ldionne added a commit: rG41bdf64d3e94: [libc++] Update all the pre-defined iterator types for C++20.
var-const mentioned this in rG2151b3d093f4: [libc++][ranges][NFC] Update the status of predefined iterators..Feb 10 2022, 6:50 PM

Revision Contents

PathSize
libcxx/
include/
__memory/
4 lines
106 lines
9 lines
test/
std/
iterators/
iterator.primitives/
iterator.traits/
8 lines
predef.iterators/
insert.iterators/
back.insert.iter.ops/
back.insert.iter.cons/
insert.iterator/
default.pass.cpp
iterator_concept_conformance.compile.pass.cpp
35 lines
back.insert.iterator/
4 lines
11 lines
front.insert.iter.ops/
front.insert.iter.cons/
insert.iterator/
default.pass.cpp
iterator_concept_conformance.compile.pass.cpp
35 lines
front.insert.iterator/
4 lines
11 lines
insert.iter.ops/
insert.iter.cons/
insert.iterator/
default.pass.cpp
iterator_concept_conformance.compile.pass.cpp
23 lines
insert.iterator/
4 lines
11 lines
stream.iterators/
istream.iterator/
17 lines
istreambuf.iterator/
20 lines
ostream.iterator/
4 lines
ostream.iterator.cons.des/
42 lines
17 lines
ostreambuf.iterator/
4 lines
ostreambuf.iter.cons/
37 lines
21 lines
utilities/
memory/
storage.iterator/
7 lines

Diff 348816

libcxx/include/__memory/raw_storage_iterator.h

Show All 34 Lines
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
private: private:
_OutputIterator __x_; _OutputIterator __x_;
public: public:
typedef output_iterator_tag iterator_category; typedef output_iterator_tag iterator_category;
typedef void value_type; typedef void value_type;
#if _LIBCPP_STD_VER > 17
typedef ptrdiff_t difference_type;
#else
typedef void difference_type; typedef void difference_type;
#endif
typedef void pointer; typedef void pointer;
typedef void reference; typedef void reference;
_LIBCPP_INLINE_VISIBILITY explicit raw_storage_iterator(_OutputIterator __x) : __x_(__x) {} _LIBCPP_INLINE_VISIBILITY explicit raw_storage_iterator(_OutputIterator __x) : __x_(__x) {}
_LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator*() {return *this;} _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator*() {return *this;}
_LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(const _Tp& __element) _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(const _Tp& __element)
{::new ((void*)_VSTD::addressof(*__x_)) _Tp(__element); return *this;} {::new ((void*)_VSTD::addressof(*__x_)) _Tp(__element); return *this;}
#if _LIBCPP_STD_VER >= 14 #if _LIBCPP_STD_VER >= 14
Show All 18 Lines

libcxx/include/iterator

Show First 20 Lines • Show All 236 Lines • ▼ Show 20 Lines
operator+(typename reverse_iterator<Iterator>::difference_type n, operator+(typename reverse_iterator<Iterator>::difference_type n,
const reverse_iterator<Iterator>& x); // constexpr in C++17 const reverse_iterator<Iterator>& x); // constexpr in C++17
template <class Iterator> template <class Iterator>
constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i); // C++14, constexpr in C++17 constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i); // C++14, constexpr in C++17
template <class Container> template <class Container>
class back_insert_iterator class back_insert_iterator
: public iterator<output_iterator_tag, void, void, void, void> // until C++17
{ {
protected: protected:
Container* container; Container* container;
public: public:
typedef Container container_type; typedef Container container_type;
typedef void value_type; typedef void value_type;
typedef void difference_type; typedef void difference_type; // until C++20
typedef ptrdiff_t difference_type; // since C++20
MordanteUnsubmitted
Done
ReplyInline Actions

std::ptrdiff_t -> ptrdiff_t here and other places.

Mordante: `std::ptrdiff_t` -> `ptrdiff_t` here and other places.
typedef void reference; typedef void reference;
typedef void pointer; typedef void pointer;
constexpr back_insert_iterator() noexcept = default; // since C++20
explicit back_insert_iterator(Container& x); // constexpr in C++20 explicit back_insert_iterator(Container& x); // constexpr in C++20
back_insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20 back_insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20
back_insert_iterator& operator*(); // constexpr in C++20 back_insert_iterator& operator*(); // constexpr in C++20
back_insert_iterator& operator++(); // constexpr in C++20 back_insert_iterator& operator++(); // constexpr in C++20
back_insert_iterator operator++(int); // constexpr in C++20 back_insert_iterator operator++(int); // constexpr in C++20
}; };
template <class Container> back_insert_iterator<Container> back_inserter(Container& x); // constexpr in C++20 template <class Container> back_insert_iterator<Container> back_inserter(Container& x); // constexpr in C++20
template <class Container> template <class Container>
class front_insert_iterator class front_insert_iterator
: public iterator<output_iterator_tag, void, void, void, void> // until C++17
{ {
protected: protected:
Container* container; Container* container;
public: public:
typedef Container container_type; typedef Container container_type;
typedef void value_type; typedef void value_type;
typedef void difference_type; typedef void difference_type; // until C++20
typedef ptrdiff_t difference_type; // since C++20
typedef void reference; typedef void reference;
typedef void pointer; typedef void pointer;
constexpr front_insert_iterator() noexcept = default; // since C++20
MordanteUnsubmitted
Done
ReplyInline Actions

I miss constexpr front_insert_iterator() noexcept = default; // since C++20 and the implementation.
back_insert_iterator has the same issue.

Mordante: I miss `constexpr front_insert_iterator() noexcept = default; // since C++20` and the…
ldionneAuthorUnsubmitted
Done
ReplyInline Actions

Good catch, somehow I missed those. Thanks.

ldionne: Good catch, somehow I missed those. Thanks.
explicit front_insert_iterator(Container& x); // constexpr in C++20 explicit front_insert_iterator(Container& x); // constexpr in C++20
front_insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20 front_insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20
front_insert_iterator& operator*(); // constexpr in C++20 front_insert_iterator& operator*(); // constexpr in C++20
front_insert_iterator& operator++(); // constexpr in C++20 front_insert_iterator& operator++(); // constexpr in C++20
front_insert_iterator operator++(int); // constexpr in C++20 front_insert_iterator operator++(int); // constexpr in C++20
}; };
template <class Container> front_insert_iterator<Container> front_inserter(Container& x); // constexpr in C++20 template <class Container> front_insert_iterator<Container> front_inserter(Container& x); // constexpr in C++20
template <class Container> template <class Container>
class insert_iterator class insert_iterator
: public iterator<output_iterator_tag, void, void, void, void> // until C++17
{ {
protected: protected:
Container* container; Container* container;
typename Container::iterator iter; typename Container::iterator iter;
public: public:
typedef Container container_type; typedef Container container_type;
typedef void value_type; typedef void value_type;
typedef void difference_type; typedef void difference_type; // until C++20
typedef ptrdiff_t difference_type; // since C++20
typedef void reference; typedef void reference;
typedef void pointer; typedef void pointer;
insert_iterator() = default; // since C++20
MordanteUnsubmitted
Done
ReplyInline Actions

I miss insert_iterator() = default; // since C++20 and the implementation. (This one has no constexpr nor noexcept.)

Mordante: I miss `insert_iterator() = default; // since C++20` and the implementation. (This one has no…
insert_iterator(Container& x, typename Container::iterator i); // constexpr in C++20 insert_iterator(Container& x, typename Container::iterator i); // constexpr in C++20
insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20 insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20
insert_iterator& operator*(); // constexpr in C++20 insert_iterator& operator*(); // constexpr in C++20
insert_iterator& operator++(); // constexpr in C++20 insert_iterator& operator++(); // constexpr in C++20
insert_iterator& operator++(int); // constexpr in C++20 insert_iterator& operator++(int); // constexpr in C++20
}; };
template <class Container, class Iterator> template <class Container, class Iterator>
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Lines
constexpr move_iterator<Iterator> make_move_iterator(const Iterator& i); constexpr move_iterator<Iterator> make_move_iterator(const Iterator& i);
template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t> template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t>
class istream_iterator class istream_iterator
: public iterator<input_iterator_tag, T, Distance, const T*, const T&> // until C++17 : public iterator<input_iterator_tag, T, Distance, const T*, const T&> // until C++17
{ {
public: public:
typedef input_iterator_tag iterator_category;
typedef T value_type;
typedef Distance difference_type;
typedef const T* pointer;
typedef const T& reference;
typedef charT char_type; typedef charT char_type;
typedef traits traits_type; typedef traits traits_type;
typedef basic_istream<charT,traits> istream_type; typedef basic_istream<charT, traits> istream_type;
MordanteUnsubmitted
Done
ReplyInline Actions

Remove std:: here and similar places.

Mordante: Remove `std::` here and similar places.
constexpr istream_iterator(); constexpr istream_iterator();
istream_iterator(istream_type& s); istream_iterator(istream_type& s);
istream_iterator(const istream_iterator& x); istream_iterator(const istream_iterator& x);
~istream_iterator(); ~istream_iterator();
const T& operator*() const; const T& operator*() const;
const T* operator->() const; const T* operator->() const;
istream_iterator& operator++(); istream_iterator& operator++();
istream_iterator operator++(int); istream_iterator operator++(int);
}; };
template <class T, class charT, class traits, class Distance> template <class T, class charT, class traits, class Distance>
bool operator==(const istream_iterator<T,charT,traits,Distance>& x, bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
const istream_iterator<T,charT,traits,Distance>& y); const istream_iterator<T,charT,traits,Distance>& y);
template <class T, class charT, class traits, class Distance> template <class T, class charT, class traits, class Distance>
bool operator!=(const istream_iterator<T,charT,traits,Distance>& x, bool operator!=(const istream_iterator<T,charT,traits,Distance>& x,
const istream_iterator<T,charT,traits,Distance>& y); const istream_iterator<T,charT,traits,Distance>& y);
template <class T, class charT = char, class traits = char_traits<charT> > template <class T, class charT = char, class traits = char_traits<charT> >
class ostream_iterator class ostream_iterator
: public iterator<output_iterator_tag, void, void, void ,void> // until C++17 : public iterator<output_iterator_tag, void, void, void, void> // until C++17
{ {
public: public:
typedef output_iterator_tag iterator_category;
typedef void value_type;
typedef void difference_type; // until C++20
typedef ptrdiff_t difference_type; // since C++20
typedef void pointer;
typedef void reference;
typedef charT char_type; typedef charT char_type;
typedef traits traits_type; typedef traits traits_type;
typedef basic_ostream<charT,traits> ostream_type; typedef basic_ostream<charT,traits> ostream_type;
constexpr ostream_iterator() noexcept = default; // since C++20
ostream_iterator(ostream_type& s); ostream_iterator(ostream_type& s);
ostream_iterator(ostream_type& s, const charT* delimiter); ostream_iterator(ostream_type& s, const charT* delimiter);
ostream_iterator(const ostream_iterator& x); ostream_iterator(const ostream_iterator& x);
~ostream_iterator(); ~ostream_iterator();
ostream_iterator& operator=(const T& value); ostream_iterator& operator=(const T& value);
ostream_iterator& operator*(); ostream_iterator& operator*();
ostream_iterator& operator++(); ostream_iterator& operator++();
ostream_iterator& operator++(int); ostream_iterator& operator++(int);
}; };
template<class charT, class traits = char_traits<charT> > template<class charT, class traits = char_traits<charT> >
class istreambuf_iterator class istreambuf_iterator
: public iterator<input_iterator_tag, charT, // until C++17 : public iterator<input_iterator_tag, charT, traits::off_type, unspecified, charT> // until C++17
typename traits::off_type, unspecified,
charT>
{ {
public: public:
typedef input_iterator_tag iterator_category;
typedef charT value_type;
typedef traits::off_type difference_type;
typedef unspecified pointer;
typedef charT reference;
typedef charT char_type; typedef charT char_type;
typedef traits traits_type; typedef traits traits_type;
typedef typename traits::int_type int_type; typedef traits::int_type int_type;
typedef basic_streambuf<charT,traits> streambuf_type; typedef basic_streambuf<charT, traits> streambuf_type;
typedef basic_istream<charT,traits> istream_type; typedef basic_istream<charT, traits> istream_type;
istreambuf_iterator() noexcept; istreambuf_iterator() noexcept;
istreambuf_iterator(istream_type& s) noexcept; istreambuf_iterator(istream_type& s) noexcept;
istreambuf_iterator(streambuf_type* s) noexcept; istreambuf_iterator(streambuf_type* s) noexcept;
istreambuf_iterator(a-private-type) noexcept; istreambuf_iterator(a-private-type) noexcept;
charT operator*() const; charT operator*() const;
pointer operator->() const; pointer operator->() const;
Show All 10 Lines
bool operator!=(const istreambuf_iterator<charT,traits>& a, bool operator!=(const istreambuf_iterator<charT,traits>& a,
const istreambuf_iterator<charT,traits>& b); const istreambuf_iterator<charT,traits>& b);
template <class charT, class traits = char_traits<charT> > template <class charT, class traits = char_traits<charT> >
class ostreambuf_iterator class ostreambuf_iterator
: public iterator<output_iterator_tag, void, void, void, void> // until C++17 : public iterator<output_iterator_tag, void, void, void, void> // until C++17
{ {
public: public:
typedef output_iterator_tag iterator_category;
typedef void value_type;
typedef void difference_type; // until C++20
typedef ptrdiff_t difference_type; // since C++20
typedef void pointer;
typedef void reference;
typedef charT char_type; typedef charT char_type;
typedef traits traits_type; typedef traits traits_type;
typedef basic_streambuf<charT,traits> streambuf_type; typedef basic_streambuf<charT, traits> streambuf_type;
typedef basic_ostream<charT,traits> ostream_type; typedef basic_ostream<charT, traits> ostream_type;
constexpr ostreambuf_iterator() noexcept = default; // since C++20
ldionneAuthorUnsubmitted
Done
ReplyInline Actions

@tcanens I think this one is missing from cppreference: https://en.cppreference.com/w/cpp/iterator/ostreambuf_iterator/ostreambuf_iterator

ldionne: @tcanens I think this one is missing from cppreference: https://en.cppreference.
QuuxplusoneUnsubmitted
Done
ReplyInline Actions

It'll be DRed out of existence by p2325r3, so I bet it's not worth fixing on cppreference.
(See my LWG reflector thread of last week, "Must ostreambuf_iterator<char>().failed() == false?".)
There's an executive design decision to be made here as to whether we should just go ahead and implement p2325 (although it seems like both me and Louis have relatively independently made decisions to implement not-p2325). Either p2325 or not-p2325 would suffice to unblock @Mordante AIUI.

Quuxplusone: It'll be DRed out of existence by p2325r3, so I bet it's not worth fixing on cppreference. (See…
MordanteUnsubmitted
Done
ReplyInline Actions

Yeah when P2325 is applied the default constructors will be removed, but an output_iterator should no longer require default_constructible. For <format> I only need the back_insert_iterator to be an output_iterator.

Mordante: Yeah when P2325 is applied the default constructors will be removed, but an `output_iterator`…
ostreambuf_iterator(ostream_type& s) noexcept; ostreambuf_iterator(ostream_type& s) noexcept;
ostreambuf_iterator(streambuf_type* s) noexcept; ostreambuf_iterator(streambuf_type* s) noexcept;
ostreambuf_iterator& operator=(charT c); ostreambuf_iterator& operator=(charT c);
ostreambuf_iterator& operator*(); ostreambuf_iterator& operator*();
ostreambuf_iterator& operator++(); ostreambuf_iterator& operator++();
ostreambuf_iterator& operator++(int); ostreambuf_iterator& operator++(int);
bool failed() const noexcept; bool failed() const noexcept;
}; };
▲ Show 20 Lines • Show All 370 Lines • ▼ Show 20 Lines
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
protected: protected:
_Container* container; _Container* container;
public: public:
typedef output_iterator_tag iterator_category; typedef output_iterator_tag iterator_category;
typedef void value_type; typedef void value_type;
#if _LIBCPP_STD_VER > 17
typedef ptrdiff_t difference_type;
#else
typedef void difference_type; typedef void difference_type;
#endif
typedef void pointer; typedef void pointer;
typedef void reference; typedef void reference;
typedef _Container container_type; typedef _Container container_type;
#if _LIBCPP_STD_VER > 17
_LIBCPP_INLINE_VISIBILITY constexpr back_insert_iterator() noexcept = default;
QuuxplusoneUnsubmitted
Done
ReplyInline Actions

I strongly recommend removing the redundant constexpr and noexcept, for cleanliness' sake. (Defaulted functions are always constexpr-auto and noexcept-auto.)
Ditto line 908, 1075, 1200; already OK on line 954.

Quuxplusone: I strongly recommend removing the redundant `constexpr` and `noexcept`, for cleanliness' sake.
MordanteUnsubmitted
Done
ReplyInline Actions

I've no strong opinion about this, but I slight prefer to use the wording the standard provides. Thus including constexpr and noexept.

Mordante: I've no strong opinion about this, but I slight prefer to use the wording the standard provides.
ldionneAuthorUnsubmitted
Done
ReplyInline Actions

Same as @Mordante , which is why I did it that way.

ldionne: Same as @Mordante , which is why I did it that way.
#endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit back_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit back_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(const typename _Container::value_type& __value_) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(const typename _Container::value_type& __value_)
{container->push_back(__value_); return *this;} {container->push_back(__value_); return *this;}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(typename _Container::value_type&& __value_) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(typename _Container::value_type&& __value_)
{container->push_back(_VSTD::move(__value_)); return *this;} {container->push_back(_VSTD::move(__value_)); return *this;}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator*() {return *this;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator*() {return *this;}
Show All 17 Lines
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
protected: protected:
_Container* container; _Container* container;
public: public:
typedef output_iterator_tag iterator_category; typedef output_iterator_tag iterator_category;
typedef void value_type; typedef void value_type;
#if _LIBCPP_STD_VER > 17
typedef ptrdiff_t difference_type;
#else
typedef void difference_type; typedef void difference_type;
#endif
typedef void pointer; typedef void pointer;
typedef void reference; typedef void reference;
typedef _Container container_type; typedef _Container container_type;
#if _LIBCPP_STD_VER > 17
_LIBCPP_INLINE_VISIBILITY constexpr front_insert_iterator() noexcept = default;
#endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit front_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit front_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(const typename _Container::value_type& __value_) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(const typename _Container::value_type& __value_)
{container->push_front(__value_); return *this;} {container->push_front(__value_); return *this;}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(typename _Container::value_type&& __value_) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(typename _Container::value_type&& __value_)
{container->push_front(_VSTD::move(__value_)); return *this;} {container->push_front(_VSTD::move(__value_)); return *this;}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator*() {return *this;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator*() {return *this;}
Show All 18 Lines
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
protected: protected:
_Container* container; _Container* container;
typename _Container::iterator iter; typename _Container::iterator iter;
public: public:
typedef output_iterator_tag iterator_category; typedef output_iterator_tag iterator_category;
typedef void value_type; typedef void value_type;
#if _LIBCPP_STD_VER > 17
typedef ptrdiff_t difference_type;
#else
typedef void difference_type; typedef void difference_type;
#endif
typedef void pointer; typedef void pointer;
typedef void reference; typedef void reference;
typedef _Container container_type; typedef _Container container_type;
#if _LIBCPP_STD_VER > 17
_LIBCPP_INLINE_VISIBILITY insert_iterator() = default;
#endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator(_Container& __x, typename _Container::iterator __i) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator(_Container& __x, typename _Container::iterator __i)
: container(_VSTD::addressof(__x)), iter(__i) {} : container(_VSTD::addressof(__x)), iter(__i) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(const typename _Container::value_type& __value_) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(const typename _Container::value_type& __value_)
{iter = container->insert(iter, __value_); ++iter; return *this;} {iter = container->insert(iter, __value_); ++iter; return *this;}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(typename _Container::value_type&& __value_) _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(typename _Container::value_type&& __value_)
{iter = container->insert(iter, _VSTD::move(__value_)); ++iter; return *this;} {iter = container->insert(iter, _VSTD::move(__value_)); ++iter; return *this;}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
▲ Show 20 Lines • Show All 88 Lines • ▼ Show 20 Lines#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
: public iterator<output_iterator_tag, void, void, void, void> : public iterator<output_iterator_tag, void, void, void, void>
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
public: public:
typedef output_iterator_tag iterator_category; typedef output_iterator_tag iterator_category;
typedef void value_type; typedef void value_type;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
typedef std::ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
#else #else
typedef void difference_type; typedef void difference_type;
#endif #endif
typedef void pointer; typedef void pointer;
typedef void reference; typedef void reference;
typedef _CharT char_type; typedef _CharT char_type;
typedef _Traits traits_type; typedef _Traits traits_type;
typedef basic_ostream<_CharT, _Traits> ostream_type; typedef basic_ostream<_CharT, _Traits> ostream_type;
private: private:
ostream_type* __out_stream_; ostream_type* __out_stream_;
const char_type* __delim_; const char_type* __delim_;
public: public:
#if _LIBCPP_STD_VER > 17
_LIBCPP_INLINE_VISIBILITY constexpr ostream_iterator() noexcept = default;
#endif
_LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s) _NOEXCEPT _LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s) _NOEXCEPT
: __out_stream_(_VSTD::addressof(__s)), __delim_(nullptr) {} : __out_stream_(_VSTD::addressof(__s)), __delim_(nullptr) {}
_LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s, const _CharT* __delimiter) _NOEXCEPT _LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s, const _CharT* __delimiter) _NOEXCEPT
: __out_stream_(_VSTD::addressof(__s)), __delim_(__delimiter) {} : __out_stream_(_VSTD::addressof(__s)), __delim_(__delimiter) {}
_LIBCPP_INLINE_VISIBILITY ostream_iterator& operator=(const _Tp& __value_) _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator=(const _Tp& __value_)
{ {
*__out_stream_ << __value_; *__out_stream_ << __value_;
if (__delim_) if (__delim_)
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Lines#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
: public iterator<output_iterator_tag, void, void, void, void> : public iterator<output_iterator_tag, void, void, void, void>
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
public: public:
typedef output_iterator_tag iterator_category; typedef output_iterator_tag iterator_category;
typedef void value_type; typedef void value_type;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER > 17
typedef std::ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
#else #else
typedef void difference_type; typedef void difference_type;
#endif #endif
typedef void pointer; typedef void pointer;
typedef void reference; typedef void reference;
typedef _CharT char_type; typedef _CharT char_type;
typedef _Traits traits_type; typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type; typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_ostream<_CharT, _Traits> ostream_type; typedef basic_ostream<_CharT, _Traits> ostream_type;
private: private:
streambuf_type* __sbuf_; streambuf_type* __sbuf_;
public: public:
#if _LIBCPP_STD_VER > 17
_LIBCPP_INLINE_VISIBILITY constexpr ostreambuf_iterator() noexcept = default;
#endif
_LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(ostream_type& __s) _NOEXCEPT _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(ostream_type& __s) _NOEXCEPT
: __sbuf_(__s.rdbuf()) {} : __sbuf_(__s.rdbuf()) {}
_LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(streambuf_type* __s) _NOEXCEPT _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(streambuf_type* __s) _NOEXCEPT
: __sbuf_(__s) {} : __sbuf_(__s) {}
_LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator=(_CharT __c) _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator=(_CharT __c)
{ {
if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sputc(__c), traits_type::eof())) if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sputc(__c), traits_type::eof()))
__sbuf_ = nullptr; __sbuf_ = nullptr;
▲ Show 20 Lines • Show All 808 Lines • Show Last 20 Lines

libcxx/include/memory

Show First 20 Lines • Show All 147 Lines • ▼ Show 20 Lines
template <class T, class U> template <class T, class U>
bool operator==(const allocator<T>&, const allocator<U>&) noexcept; // constexpr in C++20 bool operator==(const allocator<T>&, const allocator<U>&) noexcept; // constexpr in C++20
template <class T, class U> template <class T, class U>
bool operator!=(const allocator<T>&, const allocator<U>&) noexcept; // constexpr in C++20 bool operator!=(const allocator<T>&, const allocator<U>&) noexcept; // constexpr in C++20
template <class OutputIterator, class T> template <class OutputIterator, class T>
class raw_storage_iterator class raw_storage_iterator // deprecated in C++17, removed in C++20
: public iterator<output_iterator_tag, void, void, void, void> // until C++17 : public iterator<output_iterator_tag, void, void, void, void> // until C++17
{ {
public: public:
typedef output_iterator_tag iterator_category;
typedef void value_type;
typedef void difference_type; // until C++20
typedef ptrdiff_t difference_type; // since C++20
typedef void pointer;
typedef void reference;
explicit raw_storage_iterator(OutputIterator x); explicit raw_storage_iterator(OutputIterator x);
raw_storage_iterator& operator*(); raw_storage_iterator& operator*();
raw_storage_iterator& operator=(const T& element); raw_storage_iterator& operator=(const T& element);
raw_storage_iterator& operator++(); raw_storage_iterator& operator++();
raw_storage_iterator operator++(int); raw_storage_iterator operator++(int);
}; };
template <class T> pair<T*,ptrdiff_t> get_temporary_buffer(ptrdiff_t n) noexcept; template <class T> pair<T*,ptrdiff_t> get_temporary_buffer(ptrdiff_t n) noexcept;
▲ Show 20 Lines • Show All 793 Lines • Show Last 20 Lines

libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
#include "test_iterators.h" #include "test_iterators.h"
#include "iterator_traits_cpp17_iterators.h" #include "iterator_traits_cpp17_iterators.h"
template <class Traits> template <class Traits>
constexpr bool has_iterator_concept_v = requires { constexpr bool has_iterator_concept_v = requires {
typename Traits::iterator_concept; typename Traits::iterator_concept;
}; };
template <class Iter, class Category, class Diff = void> template <class Iter, class Category>
constexpr bool testIOIterator() { constexpr bool testIOIterator() {
using Traits = std::iterator_traits<Iter>; using Traits = std::iterator_traits<Iter>;
static_assert(std::same_as<typename Traits::iterator_category, Category>); static_assert(std::same_as<typename Traits::iterator_category, Category>);
static_assert(std::same_as<typename Traits::value_type, void>); static_assert(std::same_as<typename Traits::value_type, void>);
static_assert(std::same_as<typename Traits::difference_type, Diff>); static_assert(std::same_as<typename Traits::difference_type, std::ptrdiff_t>);
QuuxplusoneUnsubmitted
Done
ReplyInline Actions

Nice! :)

Quuxplusone: Nice! :)
static_assert(std::same_as<typename Traits::reference, void>); static_assert(std::same_as<typename Traits::reference, void>);
static_assert(std::same_as<typename Traits::pointer, void>); static_assert(std::same_as<typename Traits::pointer, void>);
static_assert(!has_iterator_concept_v<Traits>); static_assert(!has_iterator_concept_v<Traits>);
return true; return true;
} }
template <class Iter, class ValueType, class Category> template <class Iter, class ValueType, class Category>
▲ Show 20 Lines • Show All 128 Lines • ▼ Show 20 Lines
static_assert(testIOIterator<std::back_insert_iterator<std::vector<int>>, std::output_iterator_tag>()); static_assert(testIOIterator<std::back_insert_iterator<std::vector<int>>, std::output_iterator_tag>());
static_assert(testIOIterator<std::front_insert_iterator<std::vector<int>>, std::output_iterator_tag>()); static_assert(testIOIterator<std::front_insert_iterator<std::vector<int>>, std::output_iterator_tag>());
static_assert(testIOIterator<std::insert_iterator<std::vector<int>>, std::output_iterator_tag>()); static_assert(testIOIterator<std::insert_iterator<std::vector<int>>, std::output_iterator_tag>());
static_assert(testConstWithoutConcept<std::istream_iterator<int, char>, int, std::input_iterator_tag>()); static_assert(testConstWithoutConcept<std::istream_iterator<int, char>, int, std::input_iterator_tag>());
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
static_assert(testWithoutConcept<std::istreambuf_iterator<char>, char, long long, char, char*, std::input_iterator_tag>()); static_assert(testWithoutConcept<std::istreambuf_iterator<char>, char, long long, char, char*, std::input_iterator_tag>());
static_assert(testWithoutConcept<std::move_iterator<int*>, int, std::ptrdiff_t, int&&, int*, std::random_access_iterator_tag>()); static_assert(testWithoutConcept<std::move_iterator<int*>, int, std::ptrdiff_t, int&&, int*, std::random_access_iterator_tag>());
static_assert(testIOIterator<std::ostream_iterator<int, char>, std::output_iterator_tag, std::ptrdiff_t>()); static_assert(testIOIterator<std::ostream_iterator<int, char>, std::output_iterator_tag>());
static_assert(testIOIterator<std::ostreambuf_iterator<int, char>, std::output_iterator_tag, std::ptrdiff_t>()); static_assert(testIOIterator<std::ostreambuf_iterator<int, char>, std::output_iterator_tag>());
static_assert(testConstWithoutConcept<std::cregex_iterator, std::cmatch, std::forward_iterator_tag>()); static_assert(testConstWithoutConcept<std::cregex_iterator, std::cmatch, std::forward_iterator_tag>());
static_assert(testConstWithoutConcept<std::cregex_token_iterator, std::csub_match, std::forward_iterator_tag>()); static_assert(testConstWithoutConcept<std::cregex_token_iterator, std::csub_match, std::forward_iterator_tag>());
#endif // !_LIBCPP_HAS_NO_LOCALIZATION #endif // !_LIBCPP_HAS_NO_LOCALIZATION
#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY #ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
static_assert(testWithoutConcept<std::filesystem::directory_iterator, std::filesystem::directory_entry, std::ptrdiff_t, static_assert(testWithoutConcept<std::filesystem::directory_iterator, std::filesystem::directory_entry, std::ptrdiff_t,
const std::filesystem::directory_entry&, const std::filesystem::directory_entry*, const std::filesystem::directory_entry&, const std::filesystem::directory_entry*,
std::input_iterator_tag>()); std::input_iterator_tag>());
▲ Show 20 Lines • Show All 423 Lines • Show Last 20 Lines

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/default.pass.cpp

  • This file was copied from libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/iterator_concept_conformance.compile.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-concepts
// UNSUPPORTED: gcc-10
// insert_iterator // <iterator>
#include <iterator> // class back_insert_iterator
// constexpr back_insert_iterator() noexcept = default;
#include <iterator>
#include <vector> #include <vector>
using iterator = std::insert_iterator<std::vector<int> >; #include "test_macros.h"
static_assert(!std::indirectly_readable<iterator>);
static_assert(std::indirectly_writable<iterator, int>); struct T { };
static_assert(!std::weakly_incrementable<iterator>); using Container = std::vector<T>;
static_assert(!std::input_or_output_iterator<iterator>);
static_assert(!std::sentinel_for<iterator, iterator>); constexpr bool test() {
static_assert(!std::input_iterator<iterator>); std::back_insert_iterator<Container> it;
(void)it;
return true;
}
int main(int, char**) {
ASSERT_NOEXCEPT(std::back_insert_iterator<Container>());
test();
static_assert(test());
return 0;
}

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/iterator_concept_conformance.compile.pass.cpp

Show All 13 Lines
#include <iterator> #include <iterator>
#include <vector> #include <vector>
using iterator = std::back_insert_iterator<std::vector<int> >; using iterator = std::back_insert_iterator<std::vector<int> >;
static_assert(!std::indirectly_readable<iterator>); static_assert(!std::indirectly_readable<iterator>);
static_assert(std::indirectly_writable<iterator, int>); static_assert(std::indirectly_writable<iterator, int>);
static_assert(!std::weakly_incrementable<iterator>); static_assert(std::weakly_incrementable<iterator>);
static_assert(!std::input_or_output_iterator<iterator>); static_assert(std::input_or_output_iterator<iterator>);
static_assert(!std::sentinel_for<iterator, iterator>); static_assert(!std::sentinel_for<iterator, iterator>);
static_assert(!std::sized_sentinel_for<iterator, iterator>); static_assert(!std::sized_sentinel_for<iterator, iterator>);
static_assert(!std::input_iterator<iterator>); static_assert(!std::input_iterator<iterator>);

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/types.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <iterator> // <iterator>
// back_insert_iterator // back_insert_iterator
// Test nested types and data member: // Test nested types and data member:
// template <BackInsertionContainer Cont> // template <BackInsertionContainer Cont>
// class back_insert_iterator { // class back_insert_iterator
// : public iterator<output_iterator_tag, void, void, void, void> // until C++17
// {
// protected: // protected:
// Cont* container; // Cont* container;
// public: // public:
// typedef Cont container_type; // typedef Cont container_type;
// typedef void value_type; // typedef void value_type;
// typedef void difference_type; // typedef void difference_type; // until C++20
// typedef ptrdiff_t difference_type; // since C++20
// typedef void reference; // typedef void reference;
// typedef void pointer; // typedef void pointer;
// }; // };
#include <iterator> #include <iterator>
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
Show All 12 Lines
test() test()
{ {
typedef std::back_insert_iterator<C> R; typedef std::back_insert_iterator<C> R;
C c; C c;
find_container<C> q(c); find_container<C> q(c);
q.test(); q.test();
static_assert((std::is_same<typename R::container_type, C>::value), ""); static_assert((std::is_same<typename R::container_type, C>::value), "");
static_assert((std::is_same<typename R::value_type, void>::value), ""); static_assert((std::is_same<typename R::value_type, void>::value), "");
#if TEST_STD_VER > 17
static_assert((std::is_same<typename R::difference_type, std::ptrdiff_t>::value), "");
#else
static_assert((std::is_same<typename R::difference_type, void>::value), ""); static_assert((std::is_same<typename R::difference_type, void>::value), "");
#endif
static_assert((std::is_same<typename R::reference, void>::value), ""); static_assert((std::is_same<typename R::reference, void>::value), "");
static_assert((std::is_same<typename R::pointer, void>::value), ""); static_assert((std::is_same<typename R::pointer, void>::value), "");
static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), ""); static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), "");
#if TEST_STD_VER <= 14 #if TEST_STD_VER <= 14
typedef std::iterator<std::output_iterator_tag, void, void, void, void> iterator_base; typedef std::iterator<std::output_iterator_tag, void, void, void, void> iterator_base;
static_assert((std::is_base_of<iterator_base, R>::value), ""); static_assert((std::is_base_of<iterator_base, R>::value), "");
#endif #endif
} }
int main(int, char**) int main(int, char**)
{ {
test<std::vector<int> >(); test<std::vector<int> >();
return 0; return 0;
} }

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/default.pass.cpp

  • This file was copied from libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/iterator_concept_conformance.compile.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-concepts
// UNSUPPORTED: gcc-10
// insert_iterator // <iterator>
#include <iterator> // class front_insert_iterator
// constexpr front_insert_iterator() noexcept = default;
#include <iterator>
#include <vector> #include <vector>
using iterator = std::insert_iterator<std::vector<int> >; #include "test_macros.h"
static_assert(!std::indirectly_readable<iterator>);
static_assert(std::indirectly_writable<iterator, int>); struct T { };
static_assert(!std::weakly_incrementable<iterator>); using Container = std::vector<T>;
static_assert(!std::input_or_output_iterator<iterator>);
static_assert(!std::sentinel_for<iterator, iterator>); constexpr bool test() {
static_assert(!std::input_iterator<iterator>); std::front_insert_iterator<Container> it;
(void)it;
return true;
}
int main(int, char**) {
ASSERT_NOEXCEPT(std::front_insert_iterator<Container>());
test();
static_assert(test());
return 0;
}

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/iterator_concept_conformance.compile.pass.cpp

Show All 13 Lines
#include <iterator> #include <iterator>
#include <list> #include <list>
using iterator = std::front_insert_iterator<std::list<int> >; using iterator = std::front_insert_iterator<std::list<int> >;
static_assert(!std::indirectly_readable<iterator>); static_assert(!std::indirectly_readable<iterator>);
static_assert(std::indirectly_writable<iterator, int>); static_assert(std::indirectly_writable<iterator, int>);
static_assert(!std::weakly_incrementable<iterator>); static_assert(std::weakly_incrementable<iterator>);
static_assert(!std::input_or_output_iterator<iterator>); static_assert(std::input_or_output_iterator<iterator>);
static_assert(!std::sentinel_for<iterator, iterator>); static_assert(!std::sentinel_for<iterator, iterator>);
static_assert(!std::sized_sentinel_for<iterator, iterator>); static_assert(!std::sized_sentinel_for<iterator, iterator>);
static_assert(!std::input_iterator<iterator>); static_assert(!std::input_iterator<iterator>);

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/types.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <iterator> // <iterator>
// front_insert_iterator // front_insert_iterator
// Test nested types and data member: // Test nested types and data member:
// template <class Container> // template <class Container>
// class front_insert_iterator { // class front_insert_iterator
// : public iterator<output_iterator_tag, void, void, void, void> // until C++17
// {
// protected: // protected:
// Container* container; // Container* container;
// public: // public:
// typedef Container container_type; // typedef Container container_type;
// typedef void value_type; // typedef void value_type;
// typedef void difference_type; // typedef void difference_type; // until C++20
// typedef ptrdiff_t difference_type; // since C++20
// typedef void reference; // typedef void reference;
// typedef void pointer; // typedef void pointer;
// typedef output_iterator_tag iterator_category; // typedef output_iterator_tag iterator_category;
// }; // };
#include <iterator> #include <iterator>
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
Show All 13 Lines
test() test()
{ {
typedef std::front_insert_iterator<C> R; typedef std::front_insert_iterator<C> R;
C c; C c;
find_container<C> q(c); find_container<C> q(c);
q.test(); q.test();
static_assert((std::is_same<typename R::container_type, C>::value), ""); static_assert((std::is_same<typename R::container_type, C>::value), "");
static_assert((std::is_same<typename R::value_type, void>::value), ""); static_assert((std::is_same<typename R::value_type, void>::value), "");
#if TEST_STD_VER > 17
static_assert((std::is_same<typename R::difference_type, std::ptrdiff_t>::value), "");
#else
static_assert((std::is_same<typename R::difference_type, void>::value), ""); static_assert((std::is_same<typename R::difference_type, void>::value), "");
#endif
static_assert((std::is_same<typename R::reference, void>::value), ""); static_assert((std::is_same<typename R::reference, void>::value), "");
static_assert((std::is_same<typename R::pointer, void>::value), ""); static_assert((std::is_same<typename R::pointer, void>::value), "");
static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), ""); static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), "");
#if TEST_STD_VER <= 14 #if TEST_STD_VER <= 14
typedef std::iterator<std::output_iterator_tag, void, void, void, void> iterator_base; typedef std::iterator<std::output_iterator_tag, void, void, void, void> iterator_base;
static_assert((std::is_base_of<iterator_base, R>::value), ""); static_assert((std::is_base_of<iterator_base, R>::value), "");
#endif #endif
} }
int main(int, char**) int main(int, char**)
{ {
test<std::vector<int> >(); test<std::vector<int> >();
return 0; return 0;
} }

libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.cons/default.pass.cpp

  • This file was copied from libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/iterator_concept_conformance.compile.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-concepts
// UNSUPPORTED: gcc-10
// insert_iterator // <iterator>
#include <iterator> // class insert_iterator
// insert_iterator() = default;
#include <iterator>
#include <vector> #include <vector>
using iterator = std::insert_iterator<std::vector<int> >; struct T { };
static_assert(!std::indirectly_readable<iterator>); using Container = std::vector<T>;
static_assert(std::indirectly_writable<iterator, int>);
static_assert(!std::weakly_incrementable<iterator>); int main(int, char**) {
static_assert(!std::input_or_output_iterator<iterator>); std::insert_iterator<Container> it; (void)it;
static_assert(!std::sentinel_for<iterator, iterator>); return 0;
static_assert(!std::input_iterator<iterator>); }

libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/iterator_concept_conformance.compile.pass.cpp

  • This file was copied to libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/default.pass.cpp, libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/default.pass.cpp, libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.cons/default.pass.cpp.
Show All 13 Lines
#include <iterator> #include <iterator>
#include <vector> #include <vector>
using iterator = std::insert_iterator<std::vector<int> >; using iterator = std::insert_iterator<std::vector<int> >;
static_assert(!std::indirectly_readable<iterator>); static_assert(!std::indirectly_readable<iterator>);
static_assert(std::indirectly_writable<iterator, int>); static_assert(std::indirectly_writable<iterator, int>);
static_assert(!std::weakly_incrementable<iterator>); static_assert(std::weakly_incrementable<iterator>);
static_assert(!std::input_or_output_iterator<iterator>); static_assert(std::input_or_output_iterator<iterator>);
static_assert(!std::sentinel_for<iterator, iterator>); static_assert(!std::sentinel_for<iterator, iterator>);
static_assert(!std::input_iterator<iterator>); static_assert(!std::input_iterator<iterator>);

libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <iterator> // <iterator>
// insert_iterator // insert_iterator
// Test nested types and data members: // Test nested types and data members:
// template <InsertionContainer Cont> // template <InsertionContainer Cont>
// class insert_iterator { // class insert_iterator
// : public iterator<output_iterator_tag, void, void, void, void> // until C++17
// {
// protected: // protected:
// Cont* container; // Cont* container;
// Cont::iterator iter; // Cont::iterator iter;
// public: // public:
// typedef Cont container_type; // typedef Cont container_type;
// typedef void value_type; // typedef void value_type;
// typedef void difference_type; // typedef void difference_type; // until C++20
// typedef ptrdiff_t difference_type; // since C++20
// typedef void reference; // typedef void reference;
// typedef void pointer; // typedef void pointer;
// }; // };
#include <iterator> #include <iterator>
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
#include "test_macros.h" #include "test_macros.h"
Show All 15 Lines
test() test()
{ {
typedef std::insert_iterator<C> R; typedef std::insert_iterator<C> R;
C c; C c;
find_members<C> q(c); find_members<C> q(c);
q.test(); q.test();
static_assert((std::is_same<typename R::container_type, C>::value), ""); static_assert((std::is_same<typename R::container_type, C>::value), "");
static_assert((std::is_same<typename R::value_type, void>::value), ""); static_assert((std::is_same<typename R::value_type, void>::value), "");
#if TEST_STD_VER > 17
static_assert((std::is_same<typename R::difference_type, std::ptrdiff_t>::value), "");
#else
static_assert((std::is_same<typename R::difference_type, void>::value), ""); static_assert((std::is_same<typename R::difference_type, void>::value), "");
#endif
static_assert((std::is_same<typename R::reference, void>::value), ""); static_assert((std::is_same<typename R::reference, void>::value), "");
static_assert((std::is_same<typename R::pointer, void>::value), ""); static_assert((std::is_same<typename R::pointer, void>::value), "");
static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), ""); static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), "");
#if TEST_STD_VER <= 14 #if TEST_STD_VER <= 14
typedef std::iterator<std::output_iterator_tag, void, void, void, void> iterator_base; typedef std::iterator<std::output_iterator_tag, void, void, void, void> iterator_base;
static_assert((std::is_base_of<iterator_base, R>::value), ""); static_assert((std::is_base_of<iterator_base, R>::value), "");
#endif #endif
} }
int main(int, char**) int main(int, char**)
{ {
test<std::vector<int> >(); test<std::vector<int> >();
return 0; return 0;
} }

libcxx/test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <iterator> // <iterator>
// template <class T, class charT = char, class traits = char_traits<charT>, // template <class T, class charT = char, class traits = char_traits<charT>,
// class Distance = ptrdiff_t> // class Distance = ptrdiff_t>
// class istream_iterator { // class istream_iterator
// : public iterator<input_iterator_tag, T, Distance, const T*, const T&> // until C++17
// {
// public: // public:
// typedef input_iterator_tag iterator_category;
// typedef T value_type;
// typedef Distance difference_type;
// typedef const T* pointer;
// typedef const T& reference;
//
// typedef basic_istream<charT, Traits> istream_type;
// typedef charT char_type; // typedef charT char_type;
// typedef traits traits_type; // typedef traits traits_type;
// typedef basic_istream<charT,traits> istream_type; // typedef basic_istream<charT, traits> istream_type;
// ... // ...
// //
// Before C++17, we have: // Before C++17, we have:
// If T is a literal type, then the default constructor shall be a constexpr constructor. // If T is a literal type, then the default constructor shall be a constexpr constructor.
// If T is a literal type, then this constructor shall be a trivial copy constructor. // If T is a literal type, then this constructor shall be a trivial copy constructor.
// If T is a literal type, then this destructor shall be a trivial destructor. // If T is a literal type, then this destructor shall be a trivial destructor.
// C++17 says: // C++17 says:
// If is_trivially_default_constructible_v<T> is true, then // If is_trivially_default_constructible_v<T> is true, then
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/types.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <iterator> // <iterator>
// template<class charT, class traits = char_traits<charT> > // template<class charT, class traits = char_traits<charT> >
// class istreambuf_iterator { // class istreambuf_iterator
// : public iterator<input_iterator_tag, charT, traits::off_type, unspecified, charT> // until C++17
// {
// public: // public:
// typedef input_iterator_tag iterator_category;
// typedef charT value_type;
// typedef traits::off_type difference_type;
// typedef unspecified pointer;
// typedef charT reference;
//
// typedef charT char_type; // typedef charT char_type;
// typedef traits traits_type; // typedef traits traits_type;
// typedef typename traits::int_type int_type; // typedef traits::int_type int_type;
// typedef basic_streambuf<charT,traits> streambuf_type; // typedef basic_streambuf<charT, traits> streambuf_type;
// typedef basic_istream<charT,traits> istream_type; // typedef basic_istream<charT, traits> istream_type;
// ... // ...
// //
// All specializations of istreambuf_iterator shall have a trivial copy constructor, // All specializations of istreambuf_iterator shall have a trivial copy constructor,
// a constexpr default constructor and a trivial destructor. // a constexpr default constructor and a trivial destructor.
#include <iterator> #include <iterator>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

libcxx/test/std/iterators/stream.iterators/ostream.iterator/iterator_concept_conformance.compile.pass.cpp

Show All 13 Lines
#include <iterator> #include <iterator>
#include <iosfwd> #include <iosfwd>
using iterator = std::ostream_iterator<int, std::ostream>; using iterator = std::ostream_iterator<int, std::ostream>;
static_assert(!std::indirectly_readable<iterator>); static_assert(!std::indirectly_readable<iterator>);
static_assert(std::indirectly_writable<iterator, int>); static_assert(std::indirectly_writable<iterator, int>);
static_assert(!std::weakly_incrementable<iterator>); static_assert(std::weakly_incrementable<iterator>);
static_assert(!std::input_or_output_iterator<iterator>); static_assert(std::input_or_output_iterator<iterator>);
static_assert(!std::sentinel_for<iterator, iterator>); static_assert(!std::sentinel_for<iterator, iterator>);
static_assert(!std::sized_sentinel_for<iterator, iterator>); static_assert(!std::sized_sentinel_for<iterator, iterator>);
static_assert(!std::input_iterator<iterator>); static_assert(!std::input_iterator<iterator>);

libcxx/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/default.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17
// <iterator>
// class ostream_iterator
// constexpr ostream_iterator() noexcept = default;
#include <iterator>
#include <string> // char_traits
#include "test_macros.h"
struct MyTraits : std::char_traits<char> {
MyTraits(); // This should not be called.
};
constexpr bool test() {
std::ostream_iterator<int> it;
(void)it;
std::ostream_iterator<int, char, MyTraits> wit;
(void)wit;
return true;
}
int main(int, char**) {
ASSERT_NOEXCEPT(std::ostream_iterator<int>());
ASSERT_NOEXCEPT(std::ostream_iterator<int, char, MyTraits>());
test();
static_assert(test());
return 0;
}

libcxx/test/std/iterators/stream.iterators/ostream.iterator/types.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <iterator> // <iterator>
// template <class T, class charT = char, class traits = char_traits<charT>, // template <class T, class charT = char, class traits = char_traits<charT>,
// class Distance = ptrdiff_t> // class Distance = ptrdiff_t>
// class ostream_iterator { // class ostream_iterator
// : public iterator<output_iterator_tag, void, void, void, void> // until C++17
// {
// public: // public:
// typedef output_iterator_tag iterator_category;
// typedef void value_type;
// typedef void difference_type; // until C++20
// typedef ptrdiff_t difference_type; // since C++20
// typedef void pointer;
// typedef void reference;
//
// typedef charT char_type; // typedef charT char_type;
// typedef traits traits_type; // typedef traits traits_type;
// typedef basic_istream<charT,traits> istream_type; // typedef basic_ostream<charT, traits> ostream_type;
// ... // ...
#include <cstddef> #include <cstddef>
#include <iterator> #include <iterator>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/iterator_concept_conformance.compile.pass.cpp

Show All 14 Lines
#include <iterator> #include <iterator>
#include <ostream> #include <ostream>
#include <string> #include <string>
using iterator = std::ostreambuf_iterator<char>; using iterator = std::ostreambuf_iterator<char>;
static_assert(!std::indirectly_readable<iterator>); static_assert(!std::indirectly_readable<iterator>);
static_assert(std::indirectly_writable<iterator, char>); static_assert(std::indirectly_writable<iterator, char>);
static_assert(!std::weakly_incrementable<iterator>); static_assert(std::weakly_incrementable<iterator>);
static_assert(!std::input_or_output_iterator<iterator>); static_assert(std::input_or_output_iterator<iterator>);
static_assert(!std::sentinel_for<iterator, iterator>); static_assert(!std::sentinel_for<iterator, iterator>);
static_assert(!std::sized_sentinel_for<iterator, iterator>); static_assert(!std::sized_sentinel_for<iterator, iterator>);
static_assert(!std::input_iterator<iterator>); static_assert(!std::input_iterator<iterator>);

libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/default.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17
// <iterator>
// class ostreambuf_iterator
// constexpr ostreambuf_iterator() noexcept = default;
#include <iterator>
#include "test_macros.h"
constexpr bool test() {
std::ostreambuf_iterator<char> it;
(void)it;
std::ostreambuf_iterator<wchar_t> wit;
(void)wit;
return true;
}
int main(int, char**) {
ASSERT_NOEXCEPT(std::ostreambuf_iterator<char>());
ASSERT_NOEXCEPT(std::ostreambuf_iterator<wchar_t>());
test();
static_assert(test());
return 0;
}

libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/types.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <iterator> // <iterator>
// template <class charT, class traits = char_traits<charT> > // template <class charT, class traits = char_traits<charT> >
// class ostreambuf_iterator { // class ostreambuf_iterator
// : public iterator<output_iterator_tag, void, void, void, void> // until C++17
// {
// public: // public:
// typedef output_iterator_tag iterator_category;
// typedef void value_type;
// typedef void difference_type; // until C++20
// typedef ptrdiff_t difference_type; // since C++20
// typedef void pointer;
// typedef void reference;
//
// typedef charT char_type; // typedef charT char_type;
// typedef traits traits_type; // typedef traits traits_type;
// typedef basic_streambuf<charT, traits> streambuf_type; // typedef basic_streambuf<charT, traits> streambuf_type;
// typedef basic_ostream<charT, traits> ostream_type; // typedef basic_ostream<charT, traits> ostream_type;
// ... // ...
#include <cstddef> #include <cstddef>
#include <iterator> #include <iterator>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

libcxx/test/std/utilities/memory/storage.iterator/types.compile.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
// raw_storage_iterator associated types // raw_storage_iterator associated types
#include <cstddef>
#include <memory> #include <memory>
#include <type_traits> #include <type_traits>
#include "test_macros.h"
struct T; struct T;
typedef T* OutputIt; typedef T* OutputIt;
typedef std::raw_storage_iterator<OutputIt, T> It; typedef std::raw_storage_iterator<OutputIt, T> It;
static_assert(std::is_same<It::iterator_category, std::output_iterator_tag>::value, ""); static_assert(std::is_same<It::iterator_category, std::output_iterator_tag>::value, "");
static_assert(std::is_same<It::value_type, void>::value, ""); static_assert(std::is_same<It::value_type, void>::value, "");
#if TEST_STD_VER > 17
static_assert(std::is_same<It::difference_type, std::ptrdiff_t>::value, "");
#else
static_assert(std::is_same<It::difference_type, void>::value, ""); static_assert(std::is_same<It::difference_type, void>::value, "");
#endif
static_assert(std::is_same<It::pointer, void>::value, ""); static_assert(std::is_same<It::pointer, void>::value, "");
static_assert(std::is_same<It::reference, void>::value, ""); static_assert(std::is_same<It::reference, void>::value, "");