# HG changeset patch
# User John W. Eaton <jwe@octave.org>
# Date 1631810941 14400
# Node ID e424d966dca77a8c14eb41e3bb89731bedeb4c54
# Parent  f655202744be2504f14ad18618b5d644da71be3d
replace rangeidx helper classes with lambda expressions

* Range.h, Range.cc (rangeidx_helper, __rangeidx_helper): Delete.
(range<T>::index): Use lambda expression instead of rangeidx_helper
class instance.
(Range::index): Likewise, for __rangeidx_helper.

diff -r f655202744be -r e424d966dca7 liboctave/array/Range.cc
--- a/liboctave/array/Range.cc	Wed Sep 15 07:28:26 2021 -0400
+++ b/liboctave/array/Range.cc	Thu Sep 16 12:49:01 2021 -0400
@@ -454,59 +454,44 @@
     return m_limit;
 }
 
-// Helper class used solely for idx_vector.loop () function call
-class __rangeidx_helper
-{
-public:
-  __rangeidx_helper (double *a, double b, double i, double l, octave_idx_type n)
-    : m_array (a), m_base (b), m_inc (i), m_limit (l), m_nmax (n-1) { }
-
-  void operator () (octave_idx_type i)
-  {
-    if (i == 0)
-      *m_array++ = m_base;
-    else if (i < m_nmax)
-      *m_array++ = m_base + i * m_inc;
-    else
-      *m_array++ = m_limit;
-  }
-
-private:
-
-  double *m_array, m_base, m_inc, m_limit;
-  octave_idx_type m_nmax;
-
-};
-
 Array<double>
-Range::index (const octave::idx_vector& i) const
+Range::index (const octave::idx_vector& idx) const
 {
   Array<double> retval;
 
   octave_idx_type n = m_numel;
 
-  if (i.is_colon ())
+  if (idx.is_colon ())
     {
       retval = matrix_value ().reshape (dim_vector (m_numel, 1));
     }
   else
     {
-      if (i.extent (n) != n)
-        octave::err_index_out_of_range (1, 1, i.extent (n), n, dims ()); // throws
+      if (idx.extent (n) != n)
+        octave::err_index_out_of_range (1, 1, idx.extent (n), n, dims ()); // throws
 
-      dim_vector rd = i.orig_dimensions ();
-      octave_idx_type il = i.length (n);
+      dim_vector idx_dims = idx.orig_dimensions ();
+      octave_idx_type idx_len = idx.length (n);
 
       // taken from Array.cc.
-      if (n != 1 && rd.isvector ())
-        rd = dim_vector (1, il);
+      if (n != 1 && idx_dims.isvector ())
+        idx_dims = dim_vector (1, idx_len);
 
-      retval.clear (rd);
+      retval.clear (idx_dims);
 
       // idx_vector loop across all values in i,
-      // executing __rangeidx_helper (i) for each i
-      i.loop (n, __rangeidx_helper (retval.fortran_vec (),
-                                    m_base, m_inc, m_limit, m_numel));
+      // executing __rangeidx_helper (i) for each index value
+
+      double *array = retval.fortran_vec ();
+
+      idx.loop (n, [=, &array] (idx_vector i) {
+        if (i == 0)
+          *array++ = m_base;
+        else if (i < m_numel - 1)
+          *array++ = m_base + i * m_inc;
+        else
+          *array++ = m_limit;
+      });
     }
 
   return retval;
diff -r f655202744be -r e424d966dca7 liboctave/array/Range.h
--- a/liboctave/array/Range.h	Wed Sep 15 07:28:26 2021 -0400
+++ b/liboctave/array/Range.h	Thu Sep 16 12:49:01 2021 -0400
@@ -39,38 +39,6 @@
 
 namespace octave
 {
-  // Helper class used solely for idx_vector.loop () function call
-
-  template <typename T>
-  class rangeidx_helper
-  {
-  public:
-
-    rangeidx_helper (T *array, T base, T increment, T final_value,
-                     octave_idx_type numel)
-      : m_array (array), m_base (base), m_increment (increment),
-        m_final (final_value),
-        m_nmax (numel-1)
-    { }
-
-    void operator () (octave_idx_type i)
-    {
-      if (i == 0)
-        // Required for proper NaN handling.
-        *m_array++ = m_nmax == 0 ? m_final : m_base;
-      else if (i < m_nmax)
-        *m_array++ = m_base + T (i) * m_increment;
-      else
-        *m_array++ = m_final;
-    }
-
-  private:
-
-    T *m_array, m_base, m_increment, m_final;
-    octave_idx_type m_nmax;
-
-  };
-
   template <typename T>
   class
   OCTAVE_API
@@ -265,35 +233,44 @@
       return elem (i, j);
     }
 
-    Array<T> index (const idx_vector& i) const
+    Array<T> index (const idx_vector& idx) const
     {
       Array<T> retval;
 
       octave_idx_type n = m_numel;
 
-      if (i.is_colon ())
+      if (idx.is_colon ())
         {
           retval = array_value ().reshape (dim_vector (m_numel, 1));
         }
       else
         {
-          if (i.extent (n) != n)
-            err_index_out_of_range (1, 1, i.extent (n), n, dims ());
+          if (idx.extent (n) != n)
+            err_index_out_of_range (1, 1, idx.extent (n), n, dims ());
 
-          dim_vector rd = i.orig_dimensions ();
-          octave_idx_type il = i.length (n);
+          dim_vector idx_dims = idx.orig_dimensions ();
+          octave_idx_type idx_len = idx.length (n);
 
           // taken from Array.cc.
-          if (n != 1 && rd.isvector ())
-            rd = dim_vector (1, il);
+          if (n != 1 && idx_dims.isvector ())
+            idx_dims = dim_vector (1, idx_len);
 
-          retval.clear (rd);
+          retval.clear (idx_dims);
 
           // idx_vector loop across all values in i,
-          // executing __rangeidx_helper (i) for each i
-          i.loop (n, rangeidx_helper<T> (retval.fortran_vec (),
-                                         m_base, m_increment, final_value (),
-                                         m_numel));
+          // executing the lambda expression for each index value.
+
+          T *array = retval.fortran_vec ();
+
+          idx.loop (n, [=, &array] (octave_idx_type i) {
+            if (i == 0)
+              // Required for proper NaN handling.
+              *array++ = m_numel == 0 ? m_final : m_base;
+            else if (i < m_numel - 1)
+              *array++ = m_base + T (i) * m_increment;
+            else
+              *array++ = m_final;
+          });
         }
 
       return retval;