Imported Upstream version 1.68.0upstream/1.68.0

1 files changed, 35 insertions, 32 deletions

diff --git a/boost/gil/color_base_algorithm.hpp b/boost/gil/color_base_algorithm.hpp
index 8b28a595f4..0a9f52be5e 100644
--- a/boost/gil/color_base_algorithm.hpp
+++ b/boost/gil/color_base_algorithm.hpp
@@ -23,10 +23,13 @@
 ////////////////////////////////////////////////////////////////////////////////////////
 
 #include <algorithm>
+
+#include <boost/config.hpp>
 #include <boost/type_traits.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/mpl/contains.hpp>
 #include <boost/mpl/at.hpp>
+
 #include "gil_config.hpp"
 #include "gil_concept.hpp"
 #include "utilities.hpp"
@@ -107,8 +110,8 @@ template <typename ColorBase, int K> struct kth_semantic_element_reference_type
 /// \brief Specifies the return type of the constant semantic_at_c<K>(color_base);
 /// \ingroup ColorBaseAlgorithmSemanticAtC
 template <typename ColorBase, int K> struct kth_semantic_element_const_reference_type {
-    BOOST_STATIC_CONSTANT(int, semantic_index = (mpl::at_c<typename ColorBase::layout_t::channel_mapping_t,K>::type::value));
-    typedef typename kth_element_const_reference_type<ColorBase,semantic_index>::type type;
+	BOOST_STATIC_CONSTANT(int, semantic_index = (mpl::at_c<typename ColorBase::layout_t::channel_mapping_t,K>::type::value));
+	typedef typename kth_element_const_reference_type<ColorBase,semantic_index>::type type;
     static type       get(const ColorBase& cb) { return gil::at_c<semantic_index>(cb); }
 };
 
@@ -204,7 +207,7 @@ typename color_element_const_reference_type<ColorBase,Color>::type get_color(con
 Example:
 \code
 typedef element_type<rgb8c_planar_ptr_t>::type element_t;
-BOOST_STATIC_ASSERT((boost::is_same<element_t, const bits8*>::value));
+BOOST_STATIC_ASSERT((boost::is_same<element_t, const uint8_t*>::value));
 \endcode
 */
 /// \brief Specifies the element type of a homogeneous color base
@@ -461,19 +464,19 @@ assert(pixel[2] == 10);
 */
 
 template <typename P>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 typename element_const_reference_type<P>::type static_max(const P& p) { return detail::min_max_recur<size<P>::value>::max_(p); }
 
 template <typename P>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 typename element_reference_type<P>::type       static_max(      P& p) { return detail::min_max_recur<size<P>::value>::max_(p); }
 
 template <typename P>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 typename element_const_reference_type<P>::type static_min(const P& p) { return detail::min_max_recur<size<P>::value>::min_(p); }
 
 template <typename P>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 typename element_reference_type<P>::type       static_min(      P& p) { return detail::min_max_recur<size<P>::value>::min_(p); }
 /// \}
 
@@ -495,7 +498,7 @@ assert(rgb_red==bgr_red);  // operator== invokes static_equal
 */
 
 template <typename P1,typename P2>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 bool static_equal(const P1& p1, const P2& p2) { return detail::element_recursion<size<P1>::value>::static_equal(p1,p2); }
 
 /// \}
@@ -518,7 +521,7 @@ assert(rgb_red == bgr_red);
 */
 
 template <typename Src,typename Dst>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 void static_copy(const Src& src, Dst& dst) {  detail::element_recursion<size<Dst>::value>::static_copy(src,dst); }
 
 /// \}
@@ -537,7 +540,7 @@ assert(p == rgb8_pixel_t(10,10,10));
 \{
 */
 template <typename P,typename V>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 void static_fill(P& p, const V& v) {  detail::element_recursion<size<P>::value>::static_fill(p,v); }
 /// \}
 
@@ -563,7 +566,7 @@ assert(p == rgb8_pixel_t(0,1,2));
 */
 
 template <typename P1,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 void static_generate(P1& dst,Op op)                      { detail::element_recursion<size<P1>::value>::static_generate(dst,op); }
 /// \}
 
@@ -597,23 +600,23 @@ assert(result == rgb8_pixel_t(2,4,6));
 
 //static_transform with one source
 template <typename Src,typename Dst,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_transform(Src& src,Dst& dst,Op op)              { return detail::element_recursion<size<Dst>::value>::static_transform(src,dst,op); }
 template <typename Src,typename Dst,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_transform(const Src& src,Dst& dst,Op op)              { return detail::element_recursion<size<Dst>::value>::static_transform(src,dst,op); }
 //static_transform with two sources
 template <typename P2,typename P3,typename Dst,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_transform(P2& p2,P3& p3,Dst& dst,Op op) { return detail::element_recursion<size<Dst>::value>::static_transform(p2,p3,dst,op); }
 template <typename P2,typename P3,typename Dst,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_transform(P2& p2,const P3& p3,Dst& dst,Op op) { return detail::element_recursion<size<Dst>::value>::static_transform(p2,p3,dst,op); }
 template <typename P2,typename P3,typename Dst,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_transform(const P2& p2,P3& p3,Dst& dst,Op op) { return detail::element_recursion<size<Dst>::value>::static_transform(p2,p3,dst,op); }
 template <typename P2,typename P3,typename Dst,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_transform(const P2& p2,const P3& p3,Dst& dst,Op op) { return detail::element_recursion<size<Dst>::value>::static_transform(p2,p3,dst,op); }
 /// \}
 
@@ -634,7 +637,7 @@ void increment_elements(ColorBase& cb) {
     static_for_each(cb, increment());
 }
 
-bits8 red[2], green[2], blue[2];
+uint8_t red[2], green[2], blue[2];
 rgb8c_planar_ptr_t p1(red,green,blue);
 rgb8c_planar_ptr_t p2=p1;
 increment_elements(p1);
@@ -646,48 +649,48 @@ assert(p1 == p2);
 
 //static_for_each with one source
 template <typename P1,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_for_each(      P1& p1, Op op)                          { return detail::element_recursion<size<P1>::value>::static_for_each(p1,op); }
 template <typename P1,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_for_each(const P1& p1, Op op)                          { return detail::element_recursion<size<P1>::value>::static_for_each(p1,op); }
 //static_for_each with two sources
 template <typename P1,typename P2,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_for_each(P1& p1,      P2& p2, Op op)             { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,op); }
 template <typename P1,typename P2,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_for_each(P1& p1,const P2& p2, Op op)             { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,op); }
 template <typename P1,typename P2,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_for_each(const P1& p1,      P2& p2, Op op)             { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,op); }
 template <typename P1,typename P2,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_for_each(const P1& p1,const P2& p2, Op op)             { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,op); }
 //static_for_each with three sources
 template <typename P1,typename P2,typename P3,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_for_each(P1& p1,P2& p2,P3& p3,Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,p3,op); }
 template <typename P1,typename P2,typename P3,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_for_each(P1& p1,P2& p2,const P3& p3,Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,p3,op); }
 template <typename P1,typename P2,typename P3,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_for_each(P1& p1,const P2& p2,P3& p3,Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,p3,op); }
 template <typename P1,typename P2,typename P3,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_for_each(P1& p1,const P2& p2,const P3& p3,Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,p3,op); }
 template <typename P1,typename P2,typename P3,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_for_each(const P1& p1,P2& p2,P3& p3,Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,p3,op); }
 template <typename P1,typename P2,typename P3,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_for_each(const P1& p1,P2& p2,const P3& p3,Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,p3,op); }
 template <typename P1,typename P2,typename P3,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_for_each(const P1& p1,const P2& p2,P3& p3,Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,p3,op); }
 template <typename P1,typename P2,typename P3,typename Op>
-GIL_FORCEINLINE
+BOOST_FORCEINLINE
 Op static_for_each(const P1& p1,const P2& p2,const P3& p3,Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,p3,op); }
 ///\}