Fix implicitly-declared assignment operator is deprecated in extensio…

…n/numeric/kernel.hpp

Avoid discouraged naming with leading underscore for class member variables.
Avoid abbreviations in names.
Add assertions checks for non-empty kernel.

include/boost/gil/extension/numeric/kernel.hpp

@@ -26,86 +26,114 @@ namespace detail {
 
 /// \brief kernel adaptor for one-dimensional cores
 /// Core needs to provide size(),begin(),end(),operator[],
-///                       value_type,iterator,const_iterator,reference,const_reference
+/// value_type,iterator,const_iterator,reference,const_reference
 template <typename Core>
-class kernel_1d_adaptor : public Core {
-private:
-    std::size_t _center;
+class kernel_1d_adaptor : public Core
+{
 public:
-    kernel_1d_adaptor() : _center(0) {}
+    kernel_1d_adaptor() = default;
 
-    explicit kernel_1d_adaptor(std::size_t center_in)
-        : _center(center_in)
+    explicit kernel_1d_adaptor(std::size_t center)
+        : center_(center)
     {
-        BOOST_ASSERT(_center < this->size());
+        BOOST_ASSERT(center_ < this->size());
     }
 
-    kernel_1d_adaptor(std::size_t size_in, std::size_t center_in)
-        : Core(size_in)
-        , _center(center_in)
+    kernel_1d_adaptor(std::size_t size, std::size_t center)
+        : Core(size)
+        , center_(center)
     {
-        BOOST_ASSERT(_center < this->size());
+        BOOST_ASSERT(this->size() > 0);
+        BOOST_ASSERT(center_ < this->size()); // also implies `size() > 0`
     }
 
-    kernel_1d_adaptor(kernel_1d_adaptor const& k_in) : Core(k_in), _center(k_in._center) {}
+    kernel_1d_adaptor(kernel_1d_adaptor const& other)
+        : Core(other), center_(other.center_)
+    {
+        BOOST_ASSERT(this->size() > 0);
+        BOOST_ASSERT(center_ < this->size()); // also implies `size() > 0`
+    }
 
-    kernel_1d_adaptor& operator=(const kernel_1d_adaptor& k_in) {
-        Core::operator=(k_in);
-        _center=k_in._center;
+    kernel_1d_adaptor& operator=(kernel_1d_adaptor const& other)
+    {
+        Core::operator=(other);
+        center_ = other.center_;
         return *this;
     }
 
     std::size_t left_size() const
     {
-        BOOST_ASSERT(_center < this->size());
-        return _center;
+        BOOST_ASSERT(center_ < this->size());
+        return center_;
     }
 
     std::size_t right_size() const
     {
-        BOOST_ASSERT(_center < this->size());
-        return this->size() - _center - 1;
+        BOOST_ASSERT(center_ < this->size());
+        return this->size() - center_ - 1;
     }
 
-    std::size_t& center()       {return _center;}
-    const std::size_t& center() const {return _center;}
+    auto center() -> std::size_t&
+    {
+        BOOST_ASSERT(center_ < this->size());
+        return center_;
+    }
+
+    auto center() const -> std::size_t const&
+    {
+        BOOST_ASSERT(center_ < this->size());
+        return center_;
+    }
+
+private:
+    std::size_t center_{0};
 };
 
 } // namespace detail
 
 /// \brief variable-size kernel
-template <typename T, typename Alloc = std::allocator<T> >
-class kernel_1d : public detail::kernel_1d_adaptor<std::vector<T,Alloc>>
+template <typename T, typename Allocator = std::allocator<T> >
+class kernel_1d : public detail::kernel_1d_adaptor<std::vector<T, Allocator>>
 {
-    using parent_t = detail::kernel_1d_adaptor<std::vector<T,Alloc>>;
+    using parent_t = detail::kernel_1d_adaptor<std::vector<T, Allocator>>;
 public:
-    kernel_1d() {}
-    kernel_1d(std::size_t size_in,std::size_t center_in) : parent_t(size_in,center_in) {}
+
+    kernel_1d() = default;
+    kernel_1d(std::size_t size, std::size_t center) : parent_t(size, center) {}
+
     template <typename FwdIterator>
-    kernel_1d(FwdIterator elements, std::size_t size_in, std::size_t center_in) : parent_t(size_in,center_in) {
-        detail::copy_n(elements,size_in,this->begin());
+    kernel_1d(FwdIterator elements, std::size_t size, std::size_t center)
+        : parent_t(size, center)
+    {
+        detail::copy_n(elements, size, this->begin());
     }
-    kernel_1d(const kernel_1d& k_in)                     : parent_t(k_in) {}
+
+    kernel_1d(kernel_1d const& other) : parent_t(other) {}
+    kernel_1d& operator=(kernel_1d const& other) = default;
 };
 
 /// \brief static-size kernel
 template <typename T,std::size_t Size>
-class kernel_1d_fixed : public detail::kernel_1d_adaptor<std::array<T,Size>>
+class kernel_1d_fixed : public detail::kernel_1d_adaptor<std::array<T, Size>>
 {
-    using parent_t = detail::kernel_1d_adaptor<std::array<T,Size>>;
+    using parent_t = detail::kernel_1d_adaptor<std::array<T, Size>>;
 public:
     static constexpr std::size_t static_size = Size;
     static_assert(static_size > 0, "kernel must have size greater than 0");
     static_assert(static_size % 2 == 1, "kernel size must be odd to ensure validity at the center");
 
-    kernel_1d_fixed() {}
-    explicit kernel_1d_fixed(std::size_t center_in) : parent_t(center_in) {}
+    kernel_1d_fixed() = default;
+    explicit kernel_1d_fixed(std::size_t center) : parent_t(center) {}
 
     template <typename FwdIterator>
-    explicit kernel_1d_fixed(FwdIterator elements, std::size_t center_in) : parent_t(center_in) {
-        detail::copy_n(elements,Size,this->begin());
+    explicit kernel_1d_fixed(FwdIterator elements, std::size_t center)
+        : parent_t(center)
+    {
+        detail::copy_n(elements, Size, this->begin());
     }
-    kernel_1d_fixed(const kernel_1d_fixed& k_in)    : parent_t(k_in) {}
+
+    kernel_1d_fixed(kernel_1d_fixed const& other) : parent_t(other) {}
+    kernel_1d_fixed& operator=(kernel_1d_fixed const& other) = default;
 };
 
 // TODO: This data member is odr-used and definition at namespace scope
@@ -115,9 +143,10 @@ constexpr std::size_t kernel_1d_fixed<T, Size>::static_size;
 
 /// \brief reverse a kernel
 template <typename Kernel>
-inline Kernel reverse_kernel(const Kernel& kernel) {
+inline Kernel reverse_kernel(Kernel const& kernel)
+{
     Kernel result(kernel);
-    result.center()=kernel.right_size();
+    result.center() = kernel.right_size();
     std::reverse(result.begin(), result.end());
     return result;
 }