update boost

linx64/include/boost/gil/bit_aligned_pixel_iterator.hpp

@@ -15,6 +15,7 @@
 #include <boost/iterator/iterator_facade.hpp>
 
 #include <functional>
+#include <type_traits>
 
 namespace boost { namespace gil {
 
@@ -62,35 +63,41 @@ public:
 
     /// For some reason operator[] provided by iterator_adaptor returns a custom class that is convertible to reference
     /// We require our own reference because it is registered in iterator_traits
-    reference operator[](difference_type d) const { bit_aligned_pixel_iterator it=*this; it.advance(d); return *it; }
+    auto operator[](difference_type d) const -> reference { bit_aligned_pixel_iterator it=*this; it.advance(d); return *it; }
 
-    reference operator->()         const { return **this; }
-    const bit_range_t& bit_range() const { return _bit_range; }
-          bit_range_t& bit_range()       { return _bit_range; }
+    auto operator->() const -> reference { return **this; }
+    auto bit_range() const -> bit_range_t const& { return _bit_range; }
+    auto bit_range() -> bit_range_t& { return _bit_range; }
 private:
     bit_range_t _bit_range;
     static constexpr int bit_size = NonAlignedPixelReference::bit_size;
 
     friend class boost::iterator_core_access;
-    reference dereference()     const { return NonAlignedPixelReference(_bit_range); }
+    auto dereference() const -> reference { return NonAlignedPixelReference(_bit_range); }
     void increment()                  { ++_bit_range; }
     void decrement()                  { --_bit_range; }
     void advance(difference_type d)   { _bit_range.bit_advance(d*bit_size); }
 
-    difference_type distance_to(const bit_aligned_pixel_iterator& it) const { return _bit_range.bit_distance_to(it._bit_range) / bit_size; }
+    auto distance_to(bit_aligned_pixel_iterator const& it) const -> difference_type { return _bit_range.bit_distance_to(it._bit_range) / bit_size; }
     bool equal(const bit_aligned_pixel_iterator& it) const { return _bit_range==it._bit_range; }
 };
 
 template <typename NonAlignedPixelReference>
-struct const_iterator_type<bit_aligned_pixel_iterator<NonAlignedPixelReference> > {
-    using type = bit_aligned_pixel_iterator<typename NonAlignedPixelReference::const_reference>;
+struct const_iterator_type<bit_aligned_pixel_iterator<NonAlignedPixelReference>>
+{
+    using type =
+        bit_aligned_pixel_iterator<typename NonAlignedPixelReference::const_reference>;
 };
 
 template <typename NonAlignedPixelReference>
-struct iterator_is_mutable<bit_aligned_pixel_iterator<NonAlignedPixelReference> > : public mpl::bool_<NonAlignedPixelReference::is_mutable> {};
+struct iterator_is_mutable<bit_aligned_pixel_iterator<NonAlignedPixelReference>>
+    : std::integral_constant<bool, NonAlignedPixelReference::is_mutable>
+{};
 
 template <typename NonAlignedPixelReference>
-struct is_iterator_adaptor<bit_aligned_pixel_iterator<NonAlignedPixelReference> > : public mpl::false_ {};
+struct is_iterator_adaptor<bit_aligned_pixel_iterator<NonAlignedPixelReference>>
+    : std::false_type
+{};
 
 /////////////////////////////
 //  PixelBasedConcept
@@ -110,15 +117,19 @@ struct is_planar<bit_aligned_pixel_iterator<NonAlignedPixelReference> > : public
 /////////////////////////////
 
 template <typename NonAlignedPixelReference>
-struct byte_to_memunit<bit_aligned_pixel_iterator<NonAlignedPixelReference> > : public mpl::int_<8> {};
+struct byte_to_memunit<bit_aligned_pixel_iterator<NonAlignedPixelReference>>
+    : std::integral_constant<int, 8>
+{};
 
 template <typename NonAlignedPixelReference>
-inline std::ptrdiff_t memunit_step(const bit_aligned_pixel_iterator<NonAlignedPixelReference>&) {
+inline auto memunit_step(const bit_aligned_pixel_iterator<NonAlignedPixelReference>&) -> std::ptrdiff_t
+{
     return NonAlignedPixelReference::bit_size;
 }
 
 template <typename NonAlignedPixelReference>
-inline std::ptrdiff_t memunit_distance(const bit_aligned_pixel_iterator<NonAlignedPixelReference>& p1, const bit_aligned_pixel_iterator<NonAlignedPixelReference>& p2) {
+inline auto memunit_distance(bit_aligned_pixel_iterator<NonAlignedPixelReference> const& p1, bit_aligned_pixel_iterator<NonAlignedPixelReference> const& p2) -> std::ptrdiff_t
+{
     return (p2.bit_range().current_byte() - p1.bit_range().current_byte())*8 + p2.bit_range().bit_offset() - p1.bit_range().bit_offset();
 }
 
@@ -128,14 +139,15 @@ inline void memunit_advance(bit_aligned_pixel_iterator<NonAlignedPixelReference>
 }
 
 template <typename NonAlignedPixelReference>
-inline bit_aligned_pixel_iterator<NonAlignedPixelReference> memunit_advanced(const bit_aligned_pixel_iterator<NonAlignedPixelReference>& p, std::ptrdiff_t diff) {
+inline auto memunit_advanced(bit_aligned_pixel_iterator<NonAlignedPixelReference> const& p, std::ptrdiff_t diff) -> bit_aligned_pixel_iterator<NonAlignedPixelReference> {
     bit_aligned_pixel_iterator<NonAlignedPixelReference> ret=p;
     memunit_advance(ret, diff);
     return ret;
 }
 
 template <typename NonAlignedPixelReference> inline
-NonAlignedPixelReference memunit_advanced_ref(bit_aligned_pixel_iterator<NonAlignedPixelReference> it, std::ptrdiff_t diff) {
+auto memunit_advanced_ref(bit_aligned_pixel_iterator<NonAlignedPixelReference> it, std::ptrdiff_t diff) -> NonAlignedPixelReference
+{
     return *memunit_advanced(it,diff);
 }
 /////////////////////////////
@@ -174,11 +186,14 @@ namespace std {
 // It is important to provide an overload of uninitialized_copy for bit_aligned_pixel_iterator. The default STL implementation calls placement new,
 // which is not defined for bit_aligned_pixel_iterator.
 template <typename NonAlignedPixelReference>
-boost::gil::bit_aligned_pixel_iterator<NonAlignedPixelReference> uninitialized_copy(boost::gil::bit_aligned_pixel_iterator<NonAlignedPixelReference> first,
-                                                                                   boost::gil::bit_aligned_pixel_iterator<NonAlignedPixelReference> last,
-                                                                                   boost::gil::bit_aligned_pixel_iterator<NonAlignedPixelReference> dst) {
+auto uninitialized_copy(boost::gil::bit_aligned_pixel_iterator<NonAlignedPixelReference> first,
+    boost::gil::bit_aligned_pixel_iterator<NonAlignedPixelReference> last,
+    boost::gil::bit_aligned_pixel_iterator<NonAlignedPixelReference> dst)
+    -> boost::gil::bit_aligned_pixel_iterator<NonAlignedPixelReference>
+{
     return std::copy(first,last,dst);
 }
 
-}   // namespace std
+} // namespace std
+
 #endif