| Home | Libraries | People | FAQ | More

## Boost.Circular_buffer C++ Reference

### Header <boost/circular_buffer.hpp>

    BOOST_CB_ENABLE_DEBUG
    BOOST_CB_ASSERT(Expr)
    BOOST_CB_IS_CONVERTIBLE(Iterator, Type)
    BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS

### Header <boost/circular_buffer/base.hpp>

    namespace boost {
      template<typename T, typename Alloc> class circular_buffer;
      template<typename T, typename Alloc>
        bool operator==(const circular_buffer< T, Alloc > &,
                        const circular_buffer< T, Alloc > &);
      template<typename T, typename Alloc>
        bool operator<(const circular_buffer< T, Alloc > &,
                       const circular_buffer< T, Alloc > &);
      template<typename T, typename Alloc>
        bool operator!=(const circular_buffer< T, Alloc > &,
                        const circular_buffer< T, Alloc > &);
      template<typename T, typename Alloc>
        bool operator>(const circular_buffer< T, Alloc > &,
                       const circular_buffer< T, Alloc > &);
      template<typename T, typename Alloc>
        bool operator<=(const circular_buffer< T, Alloc > &,
                        const circular_buffer< T, Alloc > &);
      template<typename T, typename Alloc>
        bool operator>=(const circular_buffer< T, Alloc > &,
                        const circular_buffer< T, Alloc > &);
      template<typename T, typename Alloc>
        void swap(circular_buffer< T, Alloc > &, circular_buffer< T, Alloc > &);
    }

### Header <boost/circular_buffer/debug.hpp>

### Header <boost/circular_buffer/details.hpp>

### Header <boost/circular_buffer/space_optimized.hpp>

    namespace boost {
      template<typename T, typename Alloc> class circular_buffer_space_optimized;

      // Test two space optimized circular buffers for equality.
      template<typename T, typename Alloc>
        bool operator==(const circular_buffer_space_optimized< T, Alloc > & lhs,
                        const circular_buffer_space_optimized< T, Alloc > & rhs);

      // Lexicographical comparison.
      template<typename T, typename Alloc>
        bool operator<(const circular_buffer_space_optimized< T, Alloc > & lhs,
                       const circular_buffer_space_optimized< T, Alloc > & rhs);

      // Test two space optimized circular buffers for non-equality.
      template<typename T, typename Alloc>
        bool operator!=(const circular_buffer_space_optimized< T, Alloc > & lhs,
                        const circular_buffer_space_optimized< T, Alloc > & rhs);

      // Lexicographical comparison.
      template<typename T, typename Alloc>
        bool operator>(const circular_buffer_space_optimized< T, Alloc > & lhs,
                       const circular_buffer_space_optimized< T, Alloc > & rhs);

      // Lexicographical comparison.
      template<typename T, typename Alloc>
        bool operator<=(const circular_buffer_space_optimized< T, Alloc > & lhs,
                        const circular_buffer_space_optimized< T, Alloc > & rhs);

      // Lexicographical comparison.
      template<typename T, typename Alloc>
        bool operator>=(const circular_buffer_space_optimized< T, Alloc > & lhs,
                        const circular_buffer_space_optimized< T, Alloc > & rhs);

      // Swap the contents of two space optimized circular buffers.
      template<typename T, typename Alloc>
        void swap(circular_buffer_space_optimized< T, Alloc > & lhs,
                  circular_buffer_space_optimized< T, Alloc > & rhs);
    }