insert_iterator.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ITERATOR_INSERT_ITERATOR_HPP__
#define NEFORCE_CORE_ITERATOR_INSERT_ITERATOR_HPP__

 
#include "NeForce/core/typeinfo/type_traits.hpp"
NEFORCE_BEGIN_NAMESPACE__


template <typename Container>
class back_insert_iterator {
public:
    using iterator_category = output_iterator_tag; 
    using value_type = void;                       
    using difference_type = ptrdiff_t;             
    using pointer = void;                          
    using reference = void;                        
 
private:
    Container* container;
 
public:
    constexpr explicit back_insert_iterator(Container& x) noexcept :
    container(_NEFORCE addressof(x)) {}

    constexpr back_insert_iterator& operator=(const typename Container::value_type& value) {
        container->push_back(value);
        return *this;
    }

    constexpr back_insert_iterator& operator=(typename Container::value_type&& value) {
        container->push_back(_NEFORCE move(value));
        return *this;
    }
 
    NEFORCE_CONSTEXPR20 ~back_insert_iterator() noexcept = default; 
 
    NEFORCE_NODISCARD constexpr back_insert_iterator& operator*() noexcept { return *this; } 
 
    // 前置自增操作符
    constexpr back_insert_iterator& operator++() noexcept { return *this; }
    // 后置自增操作符
    constexpr back_insert_iterator operator++(int) noexcept {
        back_insert_iterator tmp = *this;
        return tmp;
    }
};

template <typename Container>
NEFORCE_NODISCARD constexpr back_insert_iterator<Container> make_back_inserter(Container& x) noexcept {
    return back_insert_iterator<Container>(x);
}
 

template <typename Container>
class front_insert_iterator {
public:
    using iterator_category = output_iterator_tag; 
    using value_type = void;                       
    using difference_type = ptrdiff_t;             
    using pointer = void;                          
    using reference = void;                        
 
private:
    Container* container; 
 
public:
    constexpr explicit front_insert_iterator(Container& x) noexcept :
    container(_NEFORCE addressof(x)) {}

    constexpr front_insert_iterator& operator=(const typename Container::value_type& value) {
        container->push_front(value);
        return *this;
    }

    constexpr front_insert_iterator& operator=(typename Container::value_type&& value) {
        container->push_front(_NEFORCE move(value));
        return *this;
    }
 
    NEFORCE_CONSTEXPR20 ~front_insert_iterator() noexcept = default; 
 
    NEFORCE_NODISCARD constexpr front_insert_iterator& operator*() noexcept { return *this; } 
 
    // 前置自增操作符
    constexpr front_insert_iterator& operator++() noexcept { return *this; }
    // 后置自增操作符
    constexpr front_insert_iterator operator++(int) noexcept {
        front_insert_iterator tmp = *this;
        return tmp;
    }
};

template <typename Container>
NEFORCE_NODISCARD constexpr front_insert_iterator<Container> make_front_inserter(Container& x) noexcept {
    return front_insert_iterator<Container>(x);
}
 

template <typename Container>
class insert_iterator {
public:
    using iterator_category = output_iterator_tag; 
    using value_type = void;                       
    using difference_type = ptrdiff_t;             
    using pointer = void;                          
    using reference = void;                        
 
private:
    Container* container;              
    typename Container::iterator iter; 
 
public:
    constexpr insert_iterator(Container& x, typename Container::iterator it) noexcept :
    container(_NEFORCE addressof(x)),
    iter(_NEFORCE move(it)) {}

    constexpr insert_iterator& operator=(const typename Container::value_type& value) {
        iter = container->insert(iter, value);
        ++iter;
        return *this;
    }

    constexpr insert_iterator& operator=(typename Container::value_type&& value) {
        iter = container->insert(iter, _NEFORCE move(value));
        ++iter;
        return *this;
    }
 
    NEFORCE_CONSTEXPR20 ~insert_iterator() noexcept = default; 
 
    NEFORCE_NODISCARD constexpr insert_iterator& operator*() noexcept { return *this; } 
 
    // 前置自增操作符
    constexpr insert_iterator& operator++() noexcept { return *this; }
    // 后置自增操作符
    constexpr insert_iterator operator++(int) noexcept {
        insert_iterator tmp = *this;
        return tmp;
    }
};

template <typename Container>
NEFORCE_NODISCARD constexpr insert_iterator<Container> make_inserter(Container& x,
                                                                     typename Container::iterator it) noexcept {
    return insert_iterator<Container>(x, it);
}
 // InsertIterators
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ITERATOR_INSERT_ITERATOR_HPP__