rename to get_internal_single

3 files changed, 28 insertions, 28 deletions

diff --git a/source/blender/blenlib/BLI_virtual_array.hh b/source/blender/blenlib/BLI_virtual_array.hh
index d15ccd695dd..ab71a70bd5f 100644
--- a/source/blender/blenlib/BLI_virtual_array.hh
+++ b/source/blender/blenlib/BLI_virtual_array.hh
@@ -108,13 +108,13 @@ template<typename T> class VArray {
 
   /* Returns the value that is returned for every index. This invokes undefined behavior if the
    * virtual array would not return the same value for every index. */
-  T get_single() const
+  T get_internal_single() const
   {
     BLI_assert(this->is_single());
     if (size_ == 1) {
       return this->get(0);
     }
-    return this->get_single_impl();
+    return this->get_internal_single_impl();
   }
 
   T operator[](const int64_t index) const
@@ -153,7 +153,7 @@ template<typename T> class VArray {
     return false;
   }
 
-  virtual T get_single_impl() const
+  virtual T get_internal_single_impl() const
   {
     /* Provide a default implementation, so that subclasses don't have to provide it. This method
      * should never be called because `is_single_impl` returns false by default. */
@@ -168,7 +168,7 @@ template<typename T> class VArray {
       initialized_copy_n(span.data(), size_, r_span.data());
     }
     else if (this->is_single()) {
-      const T single = this->get_single();
+      const T single = this->get_internal_single();
       initialized_fill_n(r_span.data(), size_, single);
     }
     else {
@@ -186,7 +186,7 @@ template<typename T> class VArray {
       uninitialized_copy_n(span.data(), size_, r_span.data());
     }
     else if (this->is_single()) {
-      const T single = this->get_single();
+      const T single = this->get_internal_single();
       uninitialized_fill_n(r_span.data(), size_, single);
     }
     else {
@@ -367,7 +367,7 @@ template<typename T> class VArray_For_Single final : public VArray<T> {
     return true;
   }
 
-  T get_single_impl() const override
+  T get_internal_single_impl() const override
   {
     return value_;
   }
@@ -536,7 +536,7 @@ inline void devirtualize_varray(const VArray<T> &varray, const Func &func, bool
   if (enable) {
     if (varray.is_single()) {
       /* `VArray_For_Single` can be used for devirtualization, because it is declared `final`. */
-      const VArray_For_Single<T> varray_single{varray.get_single(), varray.size()};
+      const VArray_For_Single<T> varray_single{varray.get_internal_single(), varray.size()};
       func(varray_single);
       return;
     }
@@ -575,19 +575,19 @@ inline void devirtualize_varray2(const VArray<T1> &varray1,
     }
     if (is_span1 && is_single2) {
       const VArray_For_Span<T1> varray1_span{varray1.get_internal_span()};
-      const VArray_For_Single<T2> varray2_single{varray2.get_single(), varray2.size()};
+      const VArray_For_Single<T2> varray2_single{varray2.get_internal_single(), varray2.size()};
       func(varray1_span, varray2_single);
       return;
     }
     if (is_single1 && is_span2) {
-      const VArray_For_Single<T1> varray1_single{varray1.get_single(), varray1.size()};
+      const VArray_For_Single<T1> varray1_single{varray1.get_internal_single(), varray1.size()};
       const VArray_For_Span<T2> varray2_span{varray2.get_internal_span()};
       func(varray1_single, varray2_span);
       return;
     }
     if (is_single1 && is_single2) {
-      const VArray_For_Single<T1> varray1_single{varray1.get_single(), varray1.size()};
-      const VArray_For_Single<T2> varray2_single{varray2.get_single(), varray2.size()};
+      const VArray_For_Single<T1> varray1_single{varray1.get_internal_single(), varray1.size()};
+      const VArray_For_Single<T2> varray2_single{varray2.get_internal_single(), varray2.size()};
       func(varray1_single, varray2_single);
       return;
     }
diff --git a/source/blender/functions/FN_generic_virtual_array.hh b/source/blender/functions/FN_generic_virtual_array.hh
index bc9c3aa0e56..ea6d79cf16d 100644
--- a/source/blender/functions/FN_generic_virtual_array.hh
+++ b/source/blender/functions/FN_generic_virtual_array.hh
@@ -110,20 +110,20 @@ class GVArray {
   /* Copies the value that is used for every element into `r_value`, which is expected to point to
    * initialized memory. This invokes undefined behavior if the virtual array would not return the
    * same value for every index. */
-  void get_single(void *r_value) const
+  void get_internal_single(void *r_value) const
   {
     BLI_assert(this->is_single());
     if (size_ == 1) {
       this->get(0, r_value);
     }
-    this->get_single_impl(r_value);
+    this->get_internal_single_impl(r_value);
   }
 
-  /* Same as `get_single`, but `r_value` points to initialized memory. */
+  /* Same as `get_internal_single`, but `r_value` points to initialized memory. */
   void get_single_to_uninitialized(void *r_value) const
   {
     type_->construct_default(r_value);
-    this->get_single(r_value);
+    this->get_internal_single(r_value);
   }
 
   void materialize_to_uninitialized(const IndexMask mask, void *dst) const;
@@ -147,7 +147,7 @@ class GVArray {
   virtual GSpan get_internal_span_impl() const;
 
   virtual bool is_single_impl() const;
-  virtual void get_single_impl(void *UNUSED(r_value)) const;
+  virtual void get_internal_single_impl(void *UNUSED(r_value)) const;
 
   virtual const void *try_get_internal_varray_impl() const;
 };
@@ -296,7 +296,7 @@ class GVArray_For_SingleValueRef : public GVArray {
   GSpan get_internal_span_impl() const override;
 
   bool is_single_impl() const override;
-  void get_single_impl(void *r_value) const override;
+  void get_internal_single_impl(void *r_value) const override;
 };
 
 class GVArray_For_SingleValue : public GVArray_For_SingleValueRef {
@@ -345,9 +345,9 @@ template<typename T> class GVArray_For_VArray : public GVArray {
     return varray_->is_single();
   }
 
-  void get_single_impl(void *r_value) const override
+  void get_internal_single_impl(void *r_value) const override
   {
-    *(T *)r_value = varray_->get_single();
+    *(T *)r_value = varray_->get_internal_single();
   }
 
   const void *try_get_internal_varray_impl() const override
@@ -393,10 +393,10 @@ template<typename T> class VArray_For_GVArray : public VArray<T> {
     return varray_->is_single();
   }
 
-  T get_single_impl() const override
+  T get_internal_single_impl() const override
   {
     T value;
-    varray_->get_single(&value);
+    varray_->get_internal_single(&value);
     return value;
   }
 };
@@ -444,10 +444,10 @@ template<typename T> class VMutableArray_For_GVMutableArray : public VMutableArr
     return varray_->is_single();
   }
 
-  T get_single_impl() const override
+  T get_internal_single_impl() const override
   {
     T value;
-    varray_->get_single(&value);
+    varray_->get_internal_single(&value);
     return value;
   }
 };
@@ -493,9 +493,9 @@ template<typename T> class GVMutableArray_For_VMutableArray : public GVMutableAr
     return varray_->is_single();
   }
 
-  void get_single_impl(void *r_value) const override
+  void get_internal_single_impl(void *r_value) const override
   {
-    *(T *)r_value = varray_->get_single();
+    *(T *)r_value = varray_->get_internal_single();
   }
 
   void set_by_copy_impl(const int64_t index, const void *value) override
@@ -718,7 +718,7 @@ template<typename T> class GVArray_Typed {
     }
     else if (gvarray.is_single()) {
       T single_value;
-      gvarray.get_single(&single_value);
+      gvarray.get_internal_single(&single_value);
       varray_single_.emplace(single_value, gvarray.size());
       varray_ = &*varray_single_;
     }
diff --git a/source/blender/functions/intern/generic_virtual_array.cc b/source/blender/functions/intern/generic_virtual_array.cc
index 9a9d6f58839..108ff19e83f 100644
--- a/source/blender/functions/intern/generic_virtual_array.cc
+++ b/source/blender/functions/intern/generic_virtual_array.cc
@@ -52,7 +52,7 @@ bool GVArray::is_single_impl() const
   return false;
 }
 
-void GVArray::get_single_impl(void *UNUSED(r_value)) const
+void GVArray::get_internal_single_impl(void *UNUSED(r_value)) const
 {
   BLI_assert(false);
 }
@@ -192,7 +192,7 @@ bool GVArray_For_SingleValueRef::is_single_impl() const
   return true;
 }
 
-void GVArray_For_SingleValueRef::get_single_impl(void *r_value) const
+void GVArray_For_SingleValueRef::get_internal_single_impl(void *r_value) const
 {
   type_->copy_to_initialized(value_, r_value);
 }