Home

Libraries

People

FAQ

More

base.hpp

// Implementation of the base circular buffer.

// Copyright (c) 2003-2004 Jan Gaspar

// Use, modification, and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#if !defined(BOOST_CIRCULAR_BUFFER_BASE_HPP)
#define BOOST_CIRCULAR_BUFFER_BASE_HPP

#if defined(_MSC_VER) && _MSC_VER >= 1200
    #pragma once
#endif

#include <boost/call_traits.hpp>
#include <boost/concept_check.hpp>
#include <boost/throw_exception.hpp>
#include <boost/iterator/reverse_iterator.hpp>
#include <algorithm>
#if !defined(BOOST_NO_EXCEPTIONS)
    #include <stdexcept>
#endif
#if BOOST_CB_ENABLE_DEBUG
    #include <string.h>
#endif

namespace boost {

template <class T, class Alloc>
class circular_buffer : cb_details::cb_iterator_registry {

// Requirements
    BOOST_CLASS_REQUIRE(T, boost, CopyConstructibleConcept);

public:
// Basic types

    typedef typename Alloc::value_type value_type;

    typedef typename Alloc::pointer pointer;

    typedef typename Alloc::const_pointer const_pointer;

    typedef typename Alloc::reference reference;

    typedef typename Alloc::const_reference const_reference;


    typedef typename Alloc::difference_type difference_type;


    typedef typename Alloc::size_type size_type;

    typedef Alloc allocator_type;

    allocator_type get_allocator() const { return m_alloc; }


    allocator_type& get_allocator() { return m_alloc; }

// Helper types

    // Define a type that represents the "best" way to pass the value_type to a method.
    typedef typename call_traits<value_type>::param_type param_value_type;

    // Define a type that represents the "best" way to return the value_type from a const method.
    typedef typename call_traits<value_type>::param_type return_value_type;

// Iterators

    typedef cb_details::cb_iterator< circular_buffer<T, Alloc>, cb_details::cb_const_traits<Alloc> > const_iterator;

    typedef cb_details::cb_iterator< circular_buffer<T, Alloc>, cb_details::cb_nonconst_traits<Alloc> > iterator;

    typedef reverse_iterator<const_iterator> const_reverse_iterator;

    typedef reverse_iterator<iterator> reverse_iterator;

private:
// Member variables

    pointer m_buff;

    pointer m_end;

    pointer m_first;

    pointer m_last;

    size_type m_size;

    allocator_type m_alloc;

// Friends
#if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
    friend iterator;
    friend const_iterator;
#else
    friend struct iterator;
    friend struct const_iterator;
#endif

public:
// Element access

    iterator begin() { return iterator(this, empty() ? 0 : m_first); }

    iterator end() { return iterator(this, 0); }

    const_iterator begin() const { return const_iterator(this, empty() ? 0 : m_first); }

    const_iterator end() const { return const_iterator(this, 0); }

    reverse_iterator rbegin() { return reverse_iterator(end()); }

    reverse_iterator rend() { return reverse_iterator(begin()); }
    
    const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }

    const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }


    reference operator [] (size_type index) {
        BOOST_CB_ASSERT(index < size()); // check for invalid index
        return *add(m_first, index);
    }


    return_value_type operator [] (size_type index) const {
        BOOST_CB_ASSERT(index < size()); // check for invalid index
        return *add(m_first, index);
    }


    reference at(size_type index) {
        check_position(index);
        return (*this)[index];
    }


    return_value_type at(size_type index) const {
        check_position(index);
        return (*this)[index];
    }


    reference front() {
        BOOST_CB_ASSERT(!empty()); // check for empty buffer (front element not available)
        return *m_first;
    }


    reference back() {
        BOOST_CB_ASSERT(!empty()); // check for empty buffer (back element not available)
        return *((m_last == m_buff ? m_end : m_last) - 1);
    }


    return_value_type front() const {
        BOOST_CB_ASSERT(!empty()); // check for empty buffer (front element not available)
        return *m_first;
    }


    return_value_type back() const {
        BOOST_CB_ASSERT(!empty()); // check for empty buffer (back element not available)
        return *((m_last == m_buff ? m_end : m_last) - 1);
    }


    pointer data() {
        if (empty())
            return 0;
        if (m_first < m_last || m_last == m_buff)
            return m_first;
        size_type constructed = 0;
        pointer src = m_first;
        pointer dest = m_buff;
        pointer tmp = 0;
        BOOST_CB_TRY
        tmp = allocate(1);
        for (pointer first = m_first; dest < src; src = first) {
            for (size_type ii = 0; src < m_end; ++src, ++dest, ++ii) {
                if (dest == first) {
                    first += ii;
                    break;
                }
                if (is_uninitialized(dest)) {
                    m_alloc.construct(dest, *src);
                    ++constructed;
                } else {
                    m_alloc.construct(tmp, *src);
                    BOOST_CB_TRY
                    replace(src, *dest);
                    BOOST_CB_UNWIND(
                        destroy_item(tmp);
                        tidy(src);
                    )
                    BOOST_CB_TRY
                    replace(dest, *tmp);
                    BOOST_CB_UNWIND(
                        destroy_item(tmp);
                        tidy(dest);
                    )
                    destroy_item(tmp);
                }
            }
        }
        deallocate(tmp, 1);
        BOOST_CB_UNWIND(
            deallocate(tmp, 1);
            m_last += constructed;
            m_size += constructed;
        )
        for (dest = m_buff + size(); dest < m_end; ++dest)
            destroy_item(dest);
        m_first = m_buff;
        m_last = add(m_buff, size());
        return m_buff;
    }

// Size and capacity

    size_type size() const { return m_size; }

    size_type max_size() const { return m_alloc.max_size(); }
    

    bool empty() const { return size() == 0; }


    bool full() const { return size() == capacity(); }

    size_type capacity() const { return m_end - m_buff; }


    void set_capacity(size_type new_capacity, bool remove_front = true) {
        if (new_capacity == capacity())
            return;
        pointer buff = allocate(new_capacity);
        size_type new_size = std::min(new_capacity, size());
        BOOST_CB_TRY
        if (remove_front)
            cb_details::uninitialized_copy(end() - new_size, end(), buff, m_alloc);
        else
            cb_details::uninitialized_copy(begin(), begin() + new_size, buff, m_alloc);
        BOOST_CB_UNWIND(deallocate(buff, new_capacity))
        destroy();
        m_size = new_size;
        m_buff = m_first = buff;
        m_end = m_buff + new_capacity;
        m_last = add(m_buff, size());
    }


    void resize(size_type new_size, param_value_type item = T(), bool remove_front = true) {
        if (new_size > size()) {
            if (new_size > capacity())
                set_capacity(new_size);
            insert(end(), new_size - size(), item);
        } else {
            if (remove_front)
                erase(begin(), end() - new_size);
            else
                erase(begin() + new_size, end());
        }
    }

// Construction/Destruction


    explicit circular_buffer(
        size_type capacity,
        const allocator_type& alloc = allocator_type())
    : m_size(0), m_alloc(alloc) {
        m_first = m_last = m_buff = allocate(capacity);
        m_end = m_buff + capacity;
    }


    circular_buffer(
        size_type capacity,
        param_value_type item,
        const allocator_type& alloc = allocator_type())
    : m_size(capacity), m_alloc(alloc) {
        m_first = m_last = m_buff = allocate(capacity);
        m_end = m_buff + capacity;
        BOOST_CB_TRY
        cb_details::uninitialized_fill_n(m_buff, size(), item, m_alloc);
        BOOST_CB_UNWIND(deallocate(m_buff, capacity))
    }


    circular_buffer(const circular_buffer<T, Alloc>& cb)
    : m_size(cb.size()), m_alloc(cb.get_allocator()) {
        m_first = m_last = m_buff = allocate(cb.capacity());
        BOOST_CB_TRY
        m_end = cb_details::uninitialized_copy(cb.begin(), cb.end(), m_buff, m_alloc);
        BOOST_CB_UNWIND(deallocate(m_buff, cb.capacity()))
    }


    template <class InputIterator>
    circular_buffer(
        size_type capacity,
        InputIterator first,
        InputIterator last,
        const allocator_type& alloc = allocator_type())
    : m_alloc(alloc) {
        BOOST_CB_IS_CONVERTIBLE(InputIterator, value_type);
        BOOST_CB_ASSERT(std::distance(first, last) >= 0); // check for wrong range
        m_first = m_buff = allocate(capacity);
        m_end = m_buff + capacity;
        size_type diff = std::distance(first, last);
        if (diff > capacity) {
            std::advance(first, diff - capacity);
            m_size = capacity;
            m_last = m_buff;
        } else {
            m_size = diff;
            if (diff == capacity)
                m_last = m_buff;
            else
                m_last = m_buff + size();
        }
        BOOST_CB_TRY
        cb_details::uninitialized_copy(first, last, m_buff, m_alloc);
        BOOST_CB_UNWIND(deallocate(m_buff, capacity))
    }

    ~circular_buffer() { destroy(); }

private:
// Helper functors

    // Functor for assigning n items.
    struct assign_n {
        size_type m_n;
        param_value_type m_item;
        allocator_type& m_alloc;
        explicit assign_n(size_type n, param_value_type item, allocator_type& alloc) : m_n(n), m_item(item), m_alloc(alloc) {}
        void operator () (pointer p) const {
            cb_details::uninitialized_fill_n(p, m_n, m_item, m_alloc);
        }
    private:
        assign_n& operator = (const assign_n&); // do not generate
    };

    // Functor for assigning range of items.
    template <class InputIterator>
    struct assign_range {
        InputIterator m_first;
        InputIterator m_last;
        allocator_type& m_alloc;
        explicit assign_range(InputIterator first, InputIterator last, allocator_type& alloc) : m_first(first), m_last(last), m_alloc(alloc) {}
        void operator () (pointer p) const {
            cb_details::uninitialized_copy(m_first, m_last, p, m_alloc);
        }
    private:
        assign_range& operator = (const assign_range&); // do not generate
    };

public:
// Assign methods


    circular_buffer<T, Alloc>& operator = (const circular_buffer<T, Alloc>& cb) {
        if (this == &cb)
            return *this;
        pointer buff = allocate(cb.capacity());
        BOOST_CB_TRY
        pointer last = cb_details::uninitialized_copy(cb.begin(), cb.end(), buff, m_alloc);
        destroy();
        m_size = cb.size();
        m_first = m_buff = buff;
        m_end = m_buff + cb.capacity();
        m_last = full() ? m_buff : last;
        BOOST_CB_UNWIND(deallocate(buff, cb.capacity()))
        return *this;
    }


    void assign(size_type n, param_value_type item) { do_assign(n, assign_n(n, item, m_alloc)); }
    

    template <class InputIterator>
    void assign(InputIterator first, InputIterator last) {
        assign(first, last, cb_details::cb_iterator_category_traits<InputIterator>::tag());
    }


    void swap(circular_buffer& cb) {
        std::swap(m_alloc, cb.m_alloc); // in general this is not necessary,
                                        // because allocators should not have state
        std::swap(m_buff, cb.m_buff);
        std::swap(m_end, cb.m_end);
        std::swap(m_first, cb.m_first);
        std::swap(m_last, cb.m_last);
        std::swap(m_size, cb.m_size);
#if BOOST_CB_ENABLE_DEBUG
        invalidate_all_iterators();
        cb.invalidate_all_iterators();
#endif
    }

// push and pop


    void push_back(param_value_type item) {
        if (full()) {
            if (empty())
                return;
            replace_last(item);
            increment(m_last);
            m_first = m_last;
        } else {
            m_alloc.construct(m_last, item);
            increment(m_last);
            ++m_size;
        }
    }


    void push_back() { push_back(value_type()); }


    void push_front(param_value_type item) {
        if (full()) {
            if (empty())
                return;
            replace_first(item);
            m_last = m_first;
        } else {
            decrement(m_first);
            BOOST_CB_TRY
            m_alloc.construct(m_first, item);
            BOOST_CB_UNWIND(increment(m_first))
            ++m_size;
        }
    }


    void push_front() { push_front(value_type()); }


    void pop_back() {
        BOOST_CB_ASSERT(!empty()); // check for empty buffer (back element not available)
        decrement(m_last);
        destroy_item(m_last);
        --m_size;
    }


    void pop_front() {
        BOOST_CB_ASSERT(!empty()); // check for empty buffer (front element not available)
        destroy_item(m_first);
        increment(m_first);
        --m_size;
    }

private:
// Helper wrappers

    // Iterator dereference wrapper.
    template <class InputIterator>
    struct iterator_wrapper {
        mutable InputIterator m_it;
        explicit iterator_wrapper(InputIterator it) : m_it(it) {}
        InputIterator get_reference() const { return m_it++; }
    };

    // Item dereference wrapper.
    struct item_wrapper {
        const_pointer m_item;
        explicit item_wrapper(param_value_type item) : m_item(&item) {}
        const_pointer get_reference() const { return m_item; }
    };

public:
// Insert


    iterator insert(iterator pos, param_value_type item) {
        BOOST_CB_ASSERT(pos.is_valid()); // check for uninitialized or invalidated iterator
        if (full() && pos == begin())
            return begin();
        if (pos.m_it == 0) {
            if (full())
                replace_last(item);
            else
                m_alloc.construct(m_last, item);
            pos.m_it = m_last;
        } else {
            pointer src = m_last;
            pointer dest = m_last;
            BOOST_CB_TRY
            while (src != pos.m_it) {
                decrement(src);
                if (dest == m_last && !full())
                    m_alloc.construct(dest, *src);
                else
                    replace(dest, *src);
                decrement(dest);
            }
            replace(pos.m_it, item);
            BOOST_CB_UNWIND(
                if (dest == m_last) {
                    if (full()) {
                        increment(m_first);
                        --m_size;
                    }
                } else {
                    if (!full()) {
                        increment(m_last);
                        ++m_size;
                    }
                    tidy(dest);
                }
            )
        }
        increment(m_last);
        if (full())
            m_first = m_last;
        else
            ++m_size;
        return iterator(this, pos.m_it);
    }


    iterator insert(iterator pos) { return insert(pos, value_type()); }


    void insert(iterator pos, size_type n, param_value_type item) {
        BOOST_CB_ASSERT(pos.is_valid()); // check for uninitialized or invalidated iterator
        if (n == 0)
            return;
        size_type copy = capacity() - (end() - pos);
        if (copy == 0)
            return;
        if (n > copy)
            n = copy;
        insert_n_item(pos, n, item_wrapper(item));
    }


    template <class InputIterator>
    void insert(iterator pos, InputIterator first, InputIterator last) {
        BOOST_CB_ASSERT(pos.is_valid()); // check for uninitialized or invalidated iterator
        insert(pos, first, last, cb_details::cb_iterator_category_traits<InputIterator>::tag());
    }


    iterator rinsert(iterator pos, param_value_type item) {
        BOOST_CB_ASSERT(pos.is_valid()); // check for uninitialized or invalidated iterator
        if (full() && pos == end())
            return end();
        if (pos == begin()) {
            if (full()) {
                replace_first(item);
            } else {
                decrement(m_first);
                BOOST_CB_TRY
                m_alloc.construct(m_first, item);
                BOOST_CB_UNWIND(increment(m_first))
            }
        } else {
            pointer src = m_first;
            pointer dest = m_first;
            decrement(dest);
            pointer it = map_pointer(pos.m_it);
            pointer first = m_first;
            decrement(first);
            BOOST_CB_TRY
            while (src != it) {
                if (dest == first && !full())
                    m_alloc.construct(dest, *src);
                else
                    replace(dest, *src);
                increment(src);
                increment(dest);
            }
            replace((--pos).m_it, item);
            BOOST_CB_UNWIND(
                if (dest == first) {
                    if (full()) {
                        decrement(m_last);
                        --m_size;
                    }
                } else {
                    if (!full()) {
                        m_first = first;
                        ++m_size;
                    }
                    tidy(dest);
                }
            )
            decrement(m_first);
        }
        if (full())
            m_last = m_first;
        else
            ++m_size;
        return iterator(this, pos.m_it);
    }


    iterator rinsert(iterator pos) { return rinsert(pos, value_type()); }


    void rinsert(iterator pos, size_type n, param_value_type item) {
        BOOST_CB_ASSERT(pos.is_valid()); // check for uninitialized or invalidated iterator
        rinsert_n_item(pos, n, item_wrapper(item));
    }


    template <class InputIterator>
    void rinsert(iterator pos, InputIterator first, InputIterator last) {
        BOOST_CB_ASSERT(pos.is_valid()); // check for uninitialized or invalidated iterator
        rinsert(pos, first, last, cb_details::cb_iterator_category_traits<InputIterator>::tag());
    }

// Erase


    iterator erase(iterator pos) {
        BOOST_CB_ASSERT(pos.is_valid()); // check for uninitialized or invalidated iterator
        BOOST_CB_ASSERT(pos.m_it != 0);  // check for iterator pointing to end()
        pointer next = pos.m_it;
        increment(next);
        for (pointer p = pos.m_it; next != m_last; p = next, increment(next))
            replace(p, *next);
        decrement(m_last);
        destroy_item(m_last);
        --m_size;
#if BOOST_CB_ENABLE_DEBUG
        return empty() ? end() : iterator(this, pos.m_it);
#else
        return empty() ? end() : pos;
#endif
    }


    iterator erase(iterator first, iterator last) {
        BOOST_CB_ASSERT(first.is_valid());            // check for uninitialized or invalidated iterator
        BOOST_CB_ASSERT(last.is_valid());             // check for uninitialized or invalidated iterator
        BOOST_CB_ASSERT(first.m_buff == last.m_buff); // check for iterators of different containers
        BOOST_CB_ASSERT(first <= last);               // check for wrong range
        if (first == last)
            return first;
        pointer tmp = first.m_it;
        difference_type diff = last - first;
        while (last.m_it != 0)
            replace((first++).m_it, *last++);
        while (first.m_it != 0)
            destroy_item((first++).m_it);
        m_last = sub(m_last, diff);
        m_size -= diff;
        return empty() ? end() : iterator(this, tmp);
    }


    void clear() {
        destroy_content();
        m_first = m_last = m_buff;
        m_size = 0;
    }

private:
// Debug support

#if BOOST_CB_ENABLE_DEBUG
    
    // Predicate determining if the condition for iterator invalidation has been met.
    struct is_invalid_condition {
        pointer m_p;
        explicit is_invalid_condition(pointer p) : m_p(p) {}
        bool operator () (const cb_details::cb_iterator_base* p) const {
            return ((iterator*)p)->m_it == m_p;
        }
    };

#endif // #if BOOST_CB_ENABLE_DEBUG

// Helper methods

    void check_position(size_type index) const {
        if (index >= size())
            throw_exception(std::out_of_range("circular_buffer"));
    }

    template <class Pointer0>
    void increment(Pointer0& p) const {
        if (++p == m_end)
            p = m_buff;
    }

    template <class Pointer0>
    void decrement(Pointer0& p) const {
        if (p == m_buff)
            p = m_end;
        --p;
    }

    template <class Pointer0>
    Pointer0 add(Pointer0 p, difference_type n) const {
        return p + (n < (m_end - p) ? n : n - capacity());
    }

    template <class Pointer0>
    Pointer0 sub(Pointer0 p, difference_type n) const {
        return p - (n > (p - m_buff) ? n - capacity() : n);
    }

    pointer map_pointer(pointer p) const { return p == 0 ? m_last : p; }

    bool is_uninitialized(const_pointer p) const {
        return p >= m_last && (m_first < m_last || p < m_first);
    }


    void create_or_replace(pointer pos, param_value_type item) {
        if (is_uninitialized(pos))
            m_alloc.construct(pos, item);
        else
            replace(pos, item);
    }


    void destroy_created(pointer pos) {
        if (is_uninitialized(pos))
            destroy_item(pos);
    }

    void replace(pointer pos, param_value_type item) {
        replace(pos, item, cb_details::cb_replace_category_traits<value_type>::tag()); // invoke optimized operation for given type
#if BOOST_CB_ENABLE_DEBUG
        invalidate_iterators(is_invalid_condition(pos));
#endif
    }

    void replace(pointer pos, param_value_type item, cb_details::cb_destroy_tag) {
        m_alloc.destroy(pos);
        m_alloc.construct(pos, item);
    }

    void replace(pointer pos, param_value_type item, cb_details::cb_assign_tag) {
        *pos = item;
    }

    void replace_first(param_value_type item) {
        decrement(m_first);
        BOOST_CB_TRY
        replace(m_first, item);
        BOOST_CB_UNWIND(
            increment(m_first);
            decrement(m_last);
            --m_size;
        )
    }

    void replace_last(param_value_type item) {
        BOOST_CB_TRY
        replace(m_last, item);
        BOOST_CB_UNWIND(
            decrement(m_last);
            --m_size;
        )
    }

    void tidy(pointer p) {
        for (; m_first != p; increment(m_first), --m_size)
            destroy_item(m_first);
        increment(m_first);
        --m_size;
    }

    pointer allocate(size_type n) {
        if (n > max_size())
            throw_exception(std::length_error("circular_buffer"));
#if BOOST_CB_ENABLE_DEBUG
        pointer p = (n == 0) ? 0 : m_alloc.allocate(n, 0);
        ::memset(p, cb_details::CB_Unitialized, sizeof(value_type) * n);
        return p;
#else
        return (n == 0) ? 0 : m_alloc.allocate(n, 0);
#endif
    }

    void deallocate(pointer p, size_type n) {
        if (p != 0)
            m_alloc.deallocate(p, n);
    }

    void destroy_item(pointer p) {
        m_alloc.destroy(p);
#if BOOST_CB_ENABLE_DEBUG
        invalidate_iterators(is_invalid_condition(p));
        ::memset(p, cb_details::CB_Unitialized, sizeof(value_type));
#endif
    }

    void destroy_content() {
        for (size_type ii = 0; ii < size(); ++ii, increment(m_first))
            destroy_item(m_first);
    }

    void destroy() {
        destroy_content();
        deallocate(m_buff, capacity());
#if BOOST_CB_ENABLE_DEBUG
        invalidate_all_iterators(); // invalidate iterators pointing to end()
        m_buff = 0;
        m_first = 0;
        m_last = 0;
        m_end = 0;
#endif
    }

    template <class InputIterator>
    void assign(InputIterator n, InputIterator item, cb_details::cb_int_iterator_tag) {
        assign((size_type)n, item);
    }

    template <class InputIterator>
    void assign(InputIterator first, InputIterator last, std::input_iterator_tag) {
        BOOST_CB_IS_CONVERTIBLE(InputIterator, value_type);
        BOOST_CB_ASSERT(std::distance(first, last) >= 0); // check for wrong range
        do_assign(std::distance(first, last), assign_range<InputIterator>(first, last, m_alloc));
    }

    template <class Functor>
    void do_assign(size_type n, const Functor& fnc) {
        if (n > capacity()) {
            pointer buff = allocate(n);
            BOOST_CB_TRY
            fnc(buff);
            BOOST_CB_UNWIND(deallocate(buff, n))
            destroy();
            m_buff = buff;
            m_end = m_buff + n;
        } else {
            destroy_content();
            BOOST_CB_TRY
            fnc(m_buff);
            BOOST_CB_UNWIND(m_size = 0)
        }
        m_size = n;
        m_first = m_buff;
        m_last = add(m_buff, size());
    }

    template <class InputIterator>
    void insert(iterator pos, InputIterator n, InputIterator item, cb_details::cb_int_iterator_tag) {
        insert(pos, (size_type)n, item);
    }

    template <class InputIterator>
    void insert(iterator pos, InputIterator first, InputIterator last, std::input_iterator_tag) {
        BOOST_CB_IS_CONVERTIBLE(InputIterator, value_type);
        BOOST_CB_ASSERT(std::distance(first, last) >= 0); // check for wrong range
        difference_type n = std::distance(first, last);
        if (n == 0)
            return;
        difference_type copy = capacity() - (end() - pos);
        if (copy == 0)
            return;
        if (n > copy) {
            std::advance(first, n - copy);
            n = copy;
        }
        insert_n_item(pos, n, iterator_wrapper<InputIterator>(first));
    }

    template <class Wrapper>
    void insert_n_item(iterator pos, size_type n, const Wrapper& wrapper) {
        size_type construct = capacity() - size();
        if (construct > n)
            construct = n;
        if (pos.m_it == 0) {
            size_type ii = 0;
            pointer p = m_last;
            BOOST_CB_TRY
            for (; ii < construct; ++ii, increment(p))
                m_alloc.construct(p, *wrapper.get_reference());
            for (;ii < n; ++ii, increment(p))
                replace(p, *wrapper.get_reference());
            BOOST_CB_UNWIND(
                size_type constructed = std::min(ii, construct);
                m_last = add(m_last, constructed);
                m_size += constructed;
                if (ii >= construct)
                    tidy(p);
            )
        } else {
            pointer src = m_last;
            pointer dest = add(m_last, n - 1);
            size_type ii = 0;
            BOOST_CB_TRY
            while (src != pos.m_it) {
                decrement(src);
                create_or_replace(dest, *src);
                decrement(dest);
            }
            for (dest = pos.m_it; ii < n; ++ii, increment(dest))
                create_or_replace(dest, *wrapper.get_reference());
            BOOST_CB_UNWIND(
                for (pointer p1 = m_last, p2 = add(m_last, n - 1); p1 != src; decrement(p2)) {
                    decrement(p1);
                    destroy_created(p2);
                }
                for (n = 0, src = pos.m_it; n < ii; ++n, increment(src))
                    destroy_created(src);
                if (!is_uninitialized(dest))
                    tidy(dest);
            )
        }
        m_last = add(m_last, n);
        m_first = add(m_first, n - construct);
        m_size += construct;
    }

    template <class InputIterator>
    void rinsert(iterator pos, InputIterator n, InputIterator item, cb_details::cb_int_iterator_tag) {
        rinsert(pos, (size_type)n, item);
    }

    template <class InputIterator>
    void rinsert(iterator pos, InputIterator first, InputIterator last, std::input_iterator_tag) {
        BOOST_CB_IS_CONVERTIBLE(InputIterator, value_type);
        BOOST_CB_ASSERT(std::distance(first, last) >= 0); // check for wrong range
        rinsert_n_item(pos, std::distance(first, last), iterator_wrapper<InputIterator>(first));
    }

    template <class Wrapper>
    void rinsert_n_item(iterator pos, size_type n, const Wrapper& wrapper) {
        if (n == 0)
            return;
        size_type copy = capacity() - (pos - begin());
        if (copy == 0)
            return;
        if (n > copy)
            n = copy;
        size_type construct = capacity() - size();
        if (construct > n)
            construct = n;
        if (pos == begin()) {
            pointer p = sub(map_pointer(pos.m_it), n);
            size_type ii = n;
            BOOST_CB_TRY
            for (;ii > construct; --ii, increment(p))
                replace(p, *wrapper.get_reference());
            for (; ii > 0; --ii, increment(p))
                m_alloc.construct(p, *wrapper.get_reference());
            BOOST_CB_UNWIND(
                size_type unwind = ii < construct ? construct - ii : 0;
                pointer tmp = sub(map_pointer(pos.m_it), construct);
                for (n = 0; n < unwind; ++n, increment(tmp))
                    destroy_item(tmp);
                if (ii > construct)
                    tidy(p);
            )
        } else {
            pointer src = m_first;
            pointer dest = sub(m_first, n);
            pointer p = map_pointer(pos.m_it);
            size_type ii = 0;
            BOOST_CB_TRY
            while (src != p) {
                create_or_replace(dest, *src);
                increment(src);
                increment(dest);
            }
            dest = sub(p, n);
            for (; ii < n; ++ii, increment(dest))
                create_or_replace(dest, *wrapper.get_reference());
            BOOST_CB_UNWIND(
                for (pointer p1 = m_first, p2 = sub(m_first, n); p1 != src; increment(p1), increment(p2))
                    destroy_created(p2);
                p = sub(p, n);
                for (n = 0; n < ii; ++n, increment(p))
                    destroy_created(p);
                if (!is_uninitialized(dest))
                    tidy(dest);
            )
        }
        m_first = sub(m_first, n);
        m_last = sub(m_last, n - construct);
        m_size += construct;
    }
};

// Non-member functions

template <class T, class Alloc>
inline bool operator == (const circular_buffer<T, Alloc>& lhs,
                         const circular_buffer<T, Alloc>& rhs) {
    return lhs.size() == rhs.size() &&
        std::equal(lhs.begin(), lhs.end(), rhs.begin());
}

template <class T, class Alloc>
inline bool operator < (const circular_buffer<T, Alloc>& lhs,
                        const circular_buffer<T, Alloc>& rhs) {
    return std::lexicographical_compare(
        lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}

#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) || defined(BOOST_MSVC)

template <class T, class Alloc>
inline bool operator != (const circular_buffer<T, Alloc>& lhs,
                         const circular_buffer<T, Alloc>& rhs) {
    return !(lhs == rhs);
}

template <class T, class Alloc>
inline bool operator > (const circular_buffer<T, Alloc>& lhs,
                        const circular_buffer<T, Alloc>& rhs) {
    return rhs < lhs;
}

template <class T, class Alloc>
inline bool operator <= (const circular_buffer<T, Alloc>& lhs,
                         const circular_buffer<T, Alloc>& rhs) {
    return !(rhs < lhs);
}

template <class T, class Alloc>
inline bool operator >= (const circular_buffer<T, Alloc>& lhs,
                         const circular_buffer<T, Alloc>& rhs) {
    return !(lhs < rhs);
}

template <class T, class Alloc>
inline void swap(circular_buffer<T, Alloc>& lhs, circular_buffer<T, Alloc>& rhs) {
    lhs.swap(rhs);
}

#endif // #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) || defined(BOOST_MSVC)

} // namespace boost

#endif // #if !defined(BOOST_CIRCULAR_BUFFER_BASE_HPP)

---

Copyright © 2003-2004 Jan Gaspar

Generated by doxygen 1.3.5.