| Home | Libraries | People | FAQ | More

## Reference

### Headers

#### Header <boost/stl_interfaces/config.hpp>

    BOOST_STL_INTERFACES_USE_CONCEPTS
    BOOST_STL_INTERFACES_USE_DEDUCED_THIS
    BOOST_STL_INTERFACES_NAMESPACE_V1
    BOOST_STL_INTERFACES_NAMESPACE_V2
    BOOST_STL_INTERFACES_NAMESPACE_V3

#### Header <boost/stl_interfaces/fwd.hpp>

    namespace boost {
      namespace stl_interfaces {
        enum element_layout;
      }
    }

#### Header <boost/stl_interfaces/iterator_interface.hpp>

    BOOST_STL_INTERFACES_STATIC_ASSERT_CONCEPT(type, concept_name)
    BOOST_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS(iter, category, concept, value_type, reference, pointer, difference_type)

    namespace boost {
      namespace stl_interfaces {
        struct access;
        template<typename Derived, typename IteratorConcept, typename ValueType,
                 typename Reference, typename Pointer, typename DifferenceType>
          struct iterator_interface;
        template<typename T> struct proxy_arrow_result;
        typedef iterator_interface< Derived, IteratorConcept, ValueType, Reference, proxy_arrow_result< Reference >, DifferenceType > proxy_iterator_interface;
        template<typename IteratorInterface1, typename IteratorInterface2,
                 typename Enable = std::enable_if_t<!v1_dtl::ra_iter<IteratorInterface1>::value> >
          decltype(access::base(std::declval< IteratorInterface1 & >())==access::base(std::declval< IteratorInterface2 & >()))
          operator==(IteratorInterface1, IteratorInterface2);
        template<typename IteratorInterface1, typename IteratorInterface2>
          decltype(v1_dtl::derived_iterator(lhs), !(lhs==rhs))
          operator!=(IteratorInterface1, IteratorInterface2);
        template<typename IteratorInterface1, typename IteratorInterface2>
          unspecified operator<(IteratorInterface1, IteratorInterface2);
        template<typename IteratorInterface1, typename IteratorInterface2>
          unspecified operator<=(IteratorInterface1, IteratorInterface2);
        template<typename IteratorInterface1, typename IteratorInterface2>
          unspecified operator>(IteratorInterface1, IteratorInterface2);
        template<typename IteratorInterface1, typename IteratorInterface2>
          unspecified operator>=(IteratorInterface1, IteratorInterface2);
        template<typename D> auto operator+(D it, typename D::difference_type n);
        template<typename D> auto operator+(typename D::difference_type n, D it);
        template<typename D1, typename D2> auto operator-(D1 lhs, D2 rhs);
        template<typename D> auto operator-(D it, typename D::difference_type n);
        template<typename D1, typename D2> bool operator<(D1 lhs, D2 rhs);
        template<typename D1, typename D2> bool operator<=(D1 lhs, D2 rhs);
        template<typename D1, typename D2> bool operator>(D1 lhs, D2 rhs);
        template<typename D1, typename D2> bool operator>=(D1 lhs, D2 rhs);
        template<typename D1, typename D2> bool operator==(D1 lhs, D2 rhs);
        template<typename D1, typename D2>
          decltype(!(lhs==rhs)) operator!=(D1 lhs, D2 rhs);
        template<typename D> auto operator+(D it, typename D::difference_type n);
        template<typename D> auto operator+(typename D::difference_type n, D it);
        template<typename D1, typename D2> auto operator-(D1 lhs, D2 rhs);
        template<typename D> auto operator-(D it, typename D::difference_type n);
        template<typename D1, typename D2> bool operator<(D1 lhs, D2 rhs);
        template<typename D1, typename D2> bool operator<=(D1 lhs, D2 rhs);
        template<typename D1, typename D2> bool operator>(D1 lhs, D2 rhs);
        template<typename D1, typename D2> bool operator>=(D1 lhs, D2 rhs);
        template<typename D1, typename D2> bool operator==(D1 lhs, D2 rhs);
        template<typename D1, typename D2>
          decltype(!(lhs==rhs)) operator!=(D1 lhs, D2 rhs);
        namespace v1_dtl {
          template<typename Iterator, typename DifferenceType, typename = void>
            struct plus_eq;

          template<typename Iterator, typename DifferenceType>
            struct plus_eq<Iterator, DifferenceType, void_t< decltype(std::declval< Iterator & >()+=std::declval< DifferenceType >())>>;

          template<typename Iterator, typename = void> struct ra_iter;

          template<typename Iterator>
            struct ra_iter<Iterator, void_t< typename Iterator::iterator_concept >>;
          template<typename D, typename IteratorConcept, typename ValueType,
                   typename Reference, typename Pointer, typename DifferenceType>
            void derived_iterator(iterator_interface< D, IteratorConcept, ValueType, Reference, Pointer, DifferenceType > const &);
        }
        namespace v2_dtl {
          template<typename D, typename IteratorConcept, typename ValueType,
                   typename Reference, typename Pointer, typename DifferenceType>
            void derived_iterator(v2::iterator_interface< D, IteratorConcept, ValueType, Reference, Pointer, DifferenceType > const &);
        }
        namespace v3_dtl {
          template<typename IteratorConcept, typename ValueType,
                   typename Reference, typename Pointer, typename DifferenceType>
            void derived_iterator(v3::iterator_interface< IteratorConcept, ValueType, Reference, Pointer, DifferenceType > const &);
        }
      }
    }

#### Header <boost/stl_interfaces/reverse_iterator.hpp>

    namespace boost {
      namespace stl_interfaces {
        template<typename BidiIter>
          decltype(rhs.base()==lhs.base())
          operator==(reverse_iterator< BidiIter > lhs,
                     reverse_iterator< BidiIter > rhs);
        template<typename BidiIter1, typename BidiIter2>
          decltype(rhs.base()==lhs.base())
          operator==(reverse_iterator< BidiIter1 > lhs,
                     reverse_iterator< BidiIter2 > rhs);
        template<typename BidiIter> auto make_reverse_iterator(BidiIter);
      }
    }

#### Header <boost/stl_interfaces/sequence_container_interface.hpp>

    namespace boost {
      namespace stl_interfaces {
        template<typename Derived, element_layout Contiguity>
          struct sequence_container_interface;
        template<typename ContainerInterface>
          decltype(v1_dtl::derived_container(lhs), lhs.swap(rhs))
          swap(ContainerInterface &, ContainerInterface &);
        template<typename ContainerInterface>
          decltype(v1_dtl::derived_container(lhs), lhs.size()==rhs.size(), *lhs.begin()== *rhs.begin(), true)
          operator==(ContainerInterface const &, ContainerInterface const &);
        template<typename ContainerInterface>
          decltype(v1_dtl::derived_container(lhs), lhs==rhs)
          operator!=(ContainerInterface const &, ContainerInterface const &);
        template<typename ContainerInterface>
          decltype(v1_dtl::derived_container(lhs), *lhs.begin()< *rhs.begin(), true)
          operator<(ContainerInterface const &, ContainerInterface const &);
        template<typename ContainerInterface>
          decltype(v1_dtl::derived_container(lhs), lhs< rhs)
          operator<=(ContainerInterface const &, ContainerInterface const &);
        template<typename ContainerInterface>
          decltype(v1_dtl::derived_container(lhs), lhs< rhs)
          operator>(ContainerInterface const &, ContainerInterface const &);
        template<typename ContainerInterface>
          decltype(v1_dtl::derived_container(lhs), lhs< rhs)
          operator>=(ContainerInterface const &, ContainerInterface const &);
        namespace v1_dtl {
          template<typename D, typename = void> struct clear_impl;

          template<typename D>
            struct clear_impl<D, void_t< decltype(std::declval< D >().clear())>>;

          typedef std::is_convertible< typename std::iterator_traits< Iter >::iterator_category, std::input_iterator_tag > in_iter;
          template<typename D, element_layout Contiguity>
            void derived_container(sequence_container_interface< D, Contiguity > const &);
        }
      }
    }

#### Header <boost/stl_interfaces/view_adaptor.hpp>

    namespace boost {
      namespace stl_interfaces {
        template<typename F> struct adaptor;
        template<typename F> struct closure;
        template<typename D, typename> struct range_adaptor_closure;
        template<typename Func, typename... Args>
          auto bind_back(Func &&, Args &&...);
      }
    }

#### Header <boost/stl_interfaces/view_interface.hpp>

    namespace boost {
      namespace stl_interfaces {
        template<typename Derived, element_layout Contiguity> struct view_interface;

         BOOST_STL_INTERFACES_NAMESPACE_V1;
         BOOST_STL_INTERFACES_NAMESPACE_V2;
         BOOST_STL_INTERFACES_NAMESPACE_V3;
        template<typename ViewInterface>
          decltype(v1_dtl::derived_view(lhs), !(lhs==rhs))
          operator!=(ViewInterface, ViewInterface);
        namespace v1_dtl {
          template<typename D, element_layout Contiguity>
            void derived_view(view_interface< D, Contiguity > const &);
        }
      }
    }