Class blocking_writer_iterator

include/msd/blocking_iterator.hpp:104–179

 */
template <typename Channel>
class blocking_writer_iterator {
   public:
    /**
     * @brief The type of the elements stored in the channel.
     */
    using value_type = typename Channel::value_type;

    /**
     * @brief Constant reference to the type of the elements stored in the channel.
     */
    using reference = const value_type&;

    /**
     * @brief Supporting writing of elements.
     */
    using iterator_category = std::output_iterator_tag;

    /**
     * @brief Signed integral type for iterator difference.
     */
    using difference_type = std::ptrdiff_t;

    /**
     * @brief Pointer type to the value_type.
     */
    using pointer = const value_type*;

    /**
     * @brief Constructs a blocking iterator from a channel reference.
     *
     * @param chan Reference to the channel this iterator will write into.
     */
    explicit blocking_writer_iterator(Channel& chan) : chan_{&chan} {}

    /**
     * @brief Writes an element into the channel, blocking until space is available.
     *
     * @param value The value to be written into the channel.
     * @return The iterator itself.
     * @note There is no effect if the channel is closed.
     */
    blocking_writer_iterator& operator=(reference value)
    {
        chan_->write(value);
        return *this;
    }

    /**
     * @brief Not applicable (handled by operator=).
     *
     * @return The iterator itself.
     *
     * @note It's uncommon to return a reference to an iterator, but I don't want to return a value from the channel.
     * This iterator is supposed to be used only to write values.
     * I don't know if it's a terrible idea or not, but it looks related to the issue with MSVC
     * in the Transform test in tests/channel_test.cpp.
     */
    blocking_writer_iterator& operator*() { return *this; }