EIC code displayed by LXR master/​include/​boost/​gil/​concepts/​pixel_iterator.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:36:55

 //
 // Copyright 2005-2007 Adobe Systems Incorporated
 //
 // Distributed under 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
 //
 #ifndef BOOST_GIL_CONCEPTS_PIXEL_ITERATOR_HPP
 #define BOOST_GIL_CONCEPTS_PIXEL_ITERATOR_HPP
 
 #include <boost/gil/concepts/channel.hpp>
 #include <boost/gil/concepts/color.hpp>
 #include <boost/gil/concepts/concept_check.hpp>
 #include <boost/gil/concepts/fwd.hpp>
 #include <boost/gil/concepts/pixel.hpp>
 #include <boost/gil/concepts/pixel_based.hpp>
 
 #include <boost/iterator/iterator_concepts.hpp>
 
 #include <cstddef>
 #include <iterator>
 #include <type_traits>
 
 #if defined(BOOST_CLANG)
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunknown-pragmas"
 #pragma clang diagnostic ignored "-Wunused-local-typedefs"
 #endif
 
 #if defined(BOOST_GCC) && (BOOST_GCC >= 40900)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
 #endif
 
 namespace boost { namespace gil {
 
 // Forward declarations
 template <typename It> struct const_iterator_type;
 template <typename It> struct iterator_is_mutable;
 template <typename It> struct is_iterator_adaptor;
 template <typename It, typename NewBaseIt> struct iterator_adaptor_rebind;
 template <typename It> struct iterator_adaptor_get_base;
 
 // These iterator mutability concepts are taken from Boost concept_check.hpp.
 // Isolating mutability to result in faster compile time
 namespace detail {
 
 // Preconditions: TT Models boost_concepts::ForwardTraversalConcept
 template <class TT>
 struct ForwardIteratorIsMutableConcept
 {
     void constraints()
     {
         auto const tmp = *i;
         *i++ = tmp; // require postincrement and assignment
     }
     TT i;
 };
 
 // Preconditions: TT Models boost::BidirectionalIteratorConcept
 template <class TT>
 struct BidirectionalIteratorIsMutableConcept
 {
     void constraints()
     {
         gil_function_requires< ForwardIteratorIsMutableConcept<TT>>();
         auto const tmp = *i;
         *i-- = tmp; // require postdecrement and assignment
     }
     TT i;
 };
 
 // Preconditions: TT Models boost_concepts::RandomAccessTraversalConcept
 template <class TT>
 struct RandomAccessIteratorIsMutableConcept
 {
     void constraints()
     {
         gil_function_requires<BidirectionalIteratorIsMutableConcept<TT>>();
 
         typename std::iterator_traits<TT>::difference_type n = 0;
         ignore_unused_variable_warning(n);
         i[n] = *i; // require element access and assignment
     }
     TT i;
 };
 
 // Iterators that can be used as the base of memory_based_step_iterator require some additional functions
 // \tparam Iterator Models boost_concepts::RandomAccessTraversalConcept
 template <typename Iterator>
 struct RandomAccessIteratorIsMemoryBasedConcept
 {
     void constraints()
     {
         std::ptrdiff_t bs = memunit_step(it);
         ignore_unused_variable_warning(bs);
 
         it = memunit_advanced(it, 3);
         std::ptrdiff_t bd = memunit_distance(it, it);
         ignore_unused_variable_warning(bd);
 
         memunit_advance(it,3);
         // for performace you may also provide a customized implementation of memunit_advanced_ref
     }
     Iterator it;
 };
 
 /// \tparam Iterator Models PixelIteratorConcept
 template <typename Iterator>
 struct PixelIteratorIsMutableConcept
 {
     void constraints()
     {
         gil_function_requires<detail::RandomAccessIteratorIsMutableConcept<Iterator>>();
 
         using ref_t = typename std::remove_reference
             <
                 typename std::iterator_traits<Iterator>::reference
             >::type;
         using channel_t = typename element_type<ref_t>::type;
         gil_function_requires<detail::ChannelIsMutableConcept<channel_t>>();
     }
 };
 
 } // namespace detail
 
 /// \ingroup PixelLocatorConcept
 /// \brief Concept for locators and views that can define a type just like the given locator or view, except X and Y is swapped
 /// \code
 /// concept HasTransposedTypeConcept<typename T>
 /// {
 ///     typename transposed_type<T>;
 ///         where Metafunction<transposed_type<T> >;
 /// };
 /// \endcode
 template <typename T>
 struct HasTransposedTypeConcept
 {
     void constraints()
     {
         using type = typename transposed_type<T>::type;
         ignore_unused_variable_warning(type{});
     }
 };
 
 /// \defgroup PixelIteratorConceptPixelIterator PixelIteratorConcept
 /// \ingroup PixelIteratorConcept
 /// \brief STL iterator over pixels
 
 /// \ingroup PixelIteratorConceptPixelIterator
 /// \brief An STL random access traversal iterator over a model of PixelConcept.
 ///
 /// GIL's iterators must also provide the following metafunctions:
 ///  - \p const_iterator_type<Iterator>:   Returns a read-only equivalent of \p Iterator
 ///  - \p iterator_is_mutable<Iterator>:   Returns whether the given iterator is read-only or mutable
 ///  - \p is_iterator_adaptor<Iterator>:   Returns whether the given iterator is an adaptor over another iterator. See IteratorAdaptorConcept for additional requirements of adaptors.
 ///
 /// \code
 /// concept PixelIteratorConcept<typename Iterator>
 ///     : boost_concepts::RandomAccessTraversalConcept<Iterator>, PixelBasedConcept<Iterator>
 /// {
 ///     where PixelValueConcept<value_type>;
 ///     typename const_iterator_type<It>::type;
 ///         where PixelIteratorConcept<const_iterator_type<It>::type>;
 ///     static const bool  iterator_is_mutable<It>::value;
 ///     static const bool  is_iterator_adaptor<It>::value;   // is it an iterator adaptor
 /// };
 /// \endcode
 template <typename Iterator>
 struct PixelIteratorConcept
 {
     void constraints()
     {
         gil_function_requires<boost_concepts::RandomAccessTraversalConcept<Iterator>>();
         gil_function_requires<PixelBasedConcept<Iterator>>();
 
         using value_type = typename std::iterator_traits<Iterator>::value_type;
         gil_function_requires<PixelValueConcept<value_type>>();
 
         using const_t = typename const_iterator_type<Iterator>::type;
         static bool const is_mutable = iterator_is_mutable<Iterator>::value;
         ignore_unused_variable_warning(is_mutable);
 
         // immutable iterator must be constructible from (possibly mutable) iterator
         const_t const_it(it);
         ignore_unused_variable_warning(const_it);
 
         check_base(typename is_iterator_adaptor<Iterator>::type());
     }
 
     void check_base(std::false_type) {}
 
     void check_base(std::true_type)
     {
         using base_t = typename iterator_adaptor_get_base<Iterator>::type;
         gil_function_requires<PixelIteratorConcept<base_t>>();
     }
 
     Iterator it;
 };
 
 /// \brief Pixel iterator that allows for changing its pixel
 /// \ingroup PixelIteratorConceptPixelIterator
 /// \code
 /// concept MutablePixelIteratorConcept<PixelIteratorConcept Iterator>
 ///     : MutableRandomAccessIteratorConcept<Iterator> {};
 /// \endcode
 template <typename Iterator>
 struct MutablePixelIteratorConcept
 {
     void constraints()
     {
         gil_function_requires<PixelIteratorConcept<Iterator>>();
         gil_function_requires<detail::PixelIteratorIsMutableConcept<Iterator>>();
     }
 };
 
 /// \defgroup PixelIteratorConceptStepIterator StepIteratorConcept
 /// \ingroup PixelIteratorConcept
 /// \brief Iterator that advances by a specified step
 
 /// \ingroup PixelIteratorConceptStepIterator
 /// \brief Concept of a random-access iterator that can be advanced in memory units (bytes or bits)
 /// \code
 /// concept MemoryBasedIteratorConcept<boost_concepts::RandomAccessTraversalConcept Iterator>
 /// {
 ///     typename byte_to_memunit<Iterator>; where metafunction<byte_to_memunit<Iterator> >;
 ///     std::ptrdiff_t      memunit_step(const Iterator&);
 ///     std::ptrdiff_t      memunit_distance(const Iterator& , const Iterator&);
 ///     void                memunit_advance(Iterator&, std::ptrdiff_t diff);
 ///     Iterator            memunit_advanced(const Iterator& p, std::ptrdiff_t diff) { Iterator tmp; memunit_advance(tmp,diff); return tmp; }
 ///     Iterator::reference memunit_advanced_ref(const Iterator& p, std::ptrdiff_t diff) { return *memunit_advanced(p,diff); }
 /// };
 /// \endcode
 template <typename Iterator>
 struct MemoryBasedIteratorConcept
 {
     void constraints()
     {
         gil_function_requires<boost_concepts::RandomAccessTraversalConcept<Iterator>>();
         gil_function_requires<detail::RandomAccessIteratorIsMemoryBasedConcept<Iterator>>();
     }
 };
 
 /// \ingroup PixelIteratorConceptStepIterator
 /// \brief Step iterator concept
 ///
 /// Step iterators are iterators that have a set_step method
 /// \code
 /// concept StepIteratorConcept<boost_concepts::ForwardTraversalConcept Iterator>
 /// {
 ///     template <Integral D>
 ///     void Iterator::set_step(D step);
 /// };
 /// \endcode
 template <typename Iterator>
 struct StepIteratorConcept
 {
     void constraints()
     {
         gil_function_requires<boost_concepts::ForwardTraversalConcept<Iterator>>();
         it.set_step(0);
     }
     Iterator it;
 };
 
 
 /// \ingroup PixelIteratorConceptStepIterator
 /// \brief Step iterator that allows for modifying its current value
 /// \code
 /// concept MutableStepIteratorConcept<Mutable_ForwardIteratorConcept Iterator>
 ///     : StepIteratorConcept<Iterator> {};
 /// \endcode
 template <typename Iterator>
 struct MutableStepIteratorConcept
 {
     void constraints()
     {
         gil_function_requires<StepIteratorConcept<Iterator>>();
         gil_function_requires<detail::ForwardIteratorIsMutableConcept<Iterator>>();
     }
 };
 
 /// \defgroup PixelIteratorConceptIteratorAdaptor IteratorAdaptorConcept
 /// \ingroup PixelIteratorConcept
 /// \brief Adaptor over another iterator
 
 /// \ingroup PixelIteratorConceptIteratorAdaptor
 /// \brief Iterator adaptor is a forward iterator adapting another forward iterator.
 ///
 /// In addition to GIL iterator requirements,
 /// GIL iterator adaptors must provide the following metafunctions:
 ///  - \p is_iterator_adaptor<Iterator>:             Returns \p std::true_type
 ///  - \p iterator_adaptor_get_base<Iterator>:       Returns the base iterator type
 ///  - \p iterator_adaptor_rebind<Iterator,NewBase>: Replaces the base iterator with the new one
 ///
 /// The adaptee can be obtained from the iterator via the "base()" method.
 ///
 /// \code
 /// concept IteratorAdaptorConcept<boost_concepts::ForwardTraversalConcept Iterator>
 /// {
 ///     where SameType<is_iterator_adaptor<Iterator>::type, std::true_type>;
 ///
 ///     typename iterator_adaptor_get_base<Iterator>;
 ///         where Metafunction<iterator_adaptor_get_base<Iterator> >;
 ///         where boost_concepts::ForwardTraversalConcept<iterator_adaptor_get_base<Iterator>::type>;
 ///
 ///     typename another_iterator;
 ///     typename iterator_adaptor_rebind<Iterator,another_iterator>::type;
 ///         where boost_concepts::ForwardTraversalConcept<another_iterator>;
 ///         where IteratorAdaptorConcept<iterator_adaptor_rebind<Iterator,another_iterator>::type>;
 ///
 ///     const iterator_adaptor_get_base<Iterator>::type& Iterator::base() const;
 /// };
 /// \endcode
 template <typename Iterator>
 struct IteratorAdaptorConcept
 {
     void constraints()
     {
         gil_function_requires<boost_concepts::ForwardTraversalConcept<Iterator>>();
 
         using base_t = typename iterator_adaptor_get_base<Iterator>::type;
         gil_function_requires<boost_concepts::ForwardTraversalConcept<base_t>>();
 
         static_assert(is_iterator_adaptor<Iterator>::value, "");
         using rebind_t = typename iterator_adaptor_rebind<Iterator, void*>::type;
 
         base_t base = it.base();
         ignore_unused_variable_warning(base);
     }
     Iterator it;
 };
 
 /// \brief Iterator adaptor that is mutable
 /// \ingroup PixelIteratorConceptIteratorAdaptor
 /// \code
 /// concept MutableIteratorAdaptorConcept<Mutable_ForwardIteratorConcept Iterator>
 ///     : IteratorAdaptorConcept<Iterator> {};
 /// \endcode
 template <typename Iterator>
 struct MutableIteratorAdaptorConcept
 {
     void constraints()
     {
         gil_function_requires<IteratorAdaptorConcept<Iterator>>();
         gil_function_requires<detail::ForwardIteratorIsMutableConcept<Iterator>>();
     }
 };
 
 }} // namespace boost::gil
 
 #if defined(BOOST_CLANG)
 #pragma clang diagnostic pop
 #endif
 
 #if defined(BOOST_GCC) && (BOOST_GCC >= 40900)
 #pragma GCC diagnostic pop
 #endif
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team