Page MenuHomePhabricator
Differential D106704 Diff 361323 libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.output/output_iterator.compile.pass.cpp

Changeset View

Standalone View

View Options

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.output/output_iterator.compile.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
// UNSUPPORTED: libcpp-no-concepts
// UNSUPPORTED: gcc-10
// template<class It, class T>
// concept output_iterator;
#include <iterator>
#include <cstddef>
#include "test_iterators.h"
struct T { };
struct DerivedFromT : T { };
static_assert( std::output_iterator<output_iterator<int*>, int>);
static_assert( std::output_iterator<output_iterator<int*>, short>);
static_assert( std::output_iterator<output_iterator<int*>, long>);
static_assert( std::output_iterator<output_iterator<T*>, T>);
static_assert(!std::output_iterator<output_iterator<T const*>, T>);
static_assert( std::output_iterator<output_iterator<T*>, T const>);
static_assert( std::output_iterator<output_iterator<T*>, DerivedFromT>);
static_assert(!std::output_iterator<output_iterator<DerivedFromT*>, T>);
// Not satisfied when the iterator is not an input_or_output_iterator
static_assert(!std::output_iterator<void, int>);
static_assert(!std::output_iterator<void (*)(), int>);
static_assert(!std::output_iterator<int&, int>);
static_assert(!std::output_iterator<T, int>);
// Not satisfied when we can't assign a T to the result of *it++
struct WrongPostIncrement {
using difference_type = std::ptrdiff_t;
void operator++(int);
WrongPostIncrement& operator++();
T& operator*();
};
static_assert(std::input_or_output_iterator<WrongPostIncrement>);
MordanteUnsubmitted
Done
ReplyInline Actions

For consistency with the code above, please add a space after the opening parenthesis.

Mordante: For consistency with the code above, please add a space after the opening parenthesis.
static_assert(std::indirectly_writable<WrongPostIncrement, T>);
static_assert(!std::output_iterator<WrongPostIncrement, T>);
// Not satisfied when the iterator is not indirectly_writable with T
QuuxplusoneUnsubmitted
Done
ReplyInline Actions

// Not satisfied when we can't assign a T to the result of *it
would be clearer as re parallel construction with line 39. It took me a while to figure out what was going on here.
Admittedly, that was because I fixated on the void operator++(int) on line 42. Consider making that something like const T *operator++(int) — i.e., you should work in the entire expression *it++ = T(), don't just make *it++ ill-formed by itself.

Quuxplusone: `// Not satisfied when we can't assign a T to the result of *it` would be clearer as re…
struct NotIndirectlyWritable {
using difference_type = std::ptrdiff_t;
T* operator++(int);
NotIndirectlyWritable& operator++();
T const& operator*(); // const so we can't write to it
};
static_assert(std::input_or_output_iterator<NotIndirectlyWritable>);
MordanteUnsubmitted
Done
ReplyInline Actions

For consistency with the code above, please add a space after the opening parenthesis.

Mordante: For consistency with the code above, please add a space after the opening parenthesis.
static_assert(!std::indirectly_writable<NotIndirectlyWritable, T>);
static_assert(!std::output_iterator<NotIndirectlyWritable, T>);