[Bf-blender-cvs] [5ab8cc2eafd] functions-experimental-refactor: add generic mutable array ref

[Jacques Lucke]

Commit: 5ab8cc2eafdf5590f88ecac6c59a3a7e4b13a4ed
Author: Jacques Lucke
Date:   Tue Oct 8 11:03:56 2019 +0200
Branches: functions-experimental-refactor
https://developer.blender.org/rB5ab8cc2eafdf5590f88ecac6c59a3a7e4b13a4ed

add generic mutable array ref

===================================================================

M	source/blender/blenkernel/BKE_generic_array_ref.h
M	source/blender/blenkernel/intern/cpp_types.cc
M	source/blender/blenkernel/intern/generic_array_ref.cc

===================================================================

diff --git a/source/blender/blenkernel/BKE_generic_array_ref.h b/source/blender/blenkernel/BKE_generic_array_ref.h
index 4c9fe1359c2..274fca77a95 100644
--- a/source/blender/blenkernel/BKE_generic_array_ref.h
+++ b/source/blender/blenkernel/BKE_generic_array_ref.h
@@ -9,6 +9,7 @@
 namespace BKE {
 
 using BLI::ArrayRef;
+using BLI::MutableArrayRef;
 
 class GenericArrayRef {
  private:
@@ -41,7 +42,38 @@ class GenericArrayRef {
   }
 };
 
-class ArrayRefCPPType : public CPPType {
+class GenericMutableArrayRef {
+ private:
+  const CPPType *m_type;
+  void *m_buffer;
+  uint m_size;
+
+ public:
+  GenericMutableArrayRef(const CPPType *type) : GenericMutableArrayRef(type, nullptr, 0)
+  {
+  }
+
+  GenericMutableArrayRef(const CPPType *type, void *buffer, uint size)
+      : m_type(type), m_buffer(buffer), m_size(size)
+  {
+    BLI_assert(type != nullptr);
+    BLI_assert(buffer != nullptr || size == 0);
+    BLI_assert(type->pointer_has_valid_alignment(buffer));
+  }
+
+  uint size() const
+  {
+    return m_size;
+  }
+
+  template<typename T> MutableArrayRef<T> get_ref()
+  {
+    BLI_assert(get_cpp_type<T>().is_same_or_generalization(m_type));
+    return ArrayRef<T>((const T *)m_buffer, m_size);
+  }
+};
+
+class ArrayRefCPPType final : public CPPType {
  private:
   CPPType &m_base_type;
 
@@ -55,7 +87,22 @@ class ArrayRefCPPType : public CPPType {
   }
 };
 
+class MutableArrayRefCPPType final : public CPPType {
+ private:
+  CPPType &m_base_type;
+
+ public:
+  MutableArrayRefCPPType(CPPType &base_type);
+
+  static void ConstructDefaultCB(const CPPType *self, void *ptr)
+  {
+    const MutableArrayRefCPPType *self_ = dynamic_cast<const MutableArrayRefCPPType *>(self);
+    new (ptr) GenericMutableArrayRef(&self_->m_base_type);
+  }
+};
+
 ArrayRefCPPType &get_generic_array_ref_cpp_type(CPPType &base);
+MutableArrayRefCPPType &get_generic_mutable_array_ref_cpp_type(CPPType &base);
 
 }  // namespace BKE
 
diff --git a/source/blender/blenkernel/intern/cpp_types.cc b/source/blender/blenkernel/intern/cpp_types.cc
index 3f64d62d065..2baf92410ee 100644
--- a/source/blender/blenkernel/intern/cpp_types.cc
+++ b/source/blender/blenkernel/intern/cpp_types.cc
@@ -68,6 +68,7 @@ CPP_TYPE_DECLARE(int32);
 CPP_TYPE_DECLARE(rgba_f);
 CPP_TYPE_DECLARE(string);
 CPP_TYPE_DECLARE(GenericArrayRef);
+CPP_TYPE_DECLARE(GenericMutableArrayRef);
 
 #undef CPP_TYPE_DECLARE
 
@@ -97,6 +98,7 @@ void init_data_types()
   CPP_TYPE_CONSTRUCTION(rgba_f, BLI::rgba_f);
   CPP_TYPE_CONSTRUCTION(string, std::string);
   CPP_TYPE_CONSTRUCTION(GenericArrayRef, GenericArrayRef);
+  CPP_TYPE_CONSTRUCTION(GenericMutableArrayRef, GenericMutableArrayRef);
 
 #undef CPP_TYPE_CONSTRUCTION
 }
@@ -114,6 +116,7 @@ CPP_TYPE_GETTER(int32, int32_t)
 CPP_TYPE_GETTER(rgba_f, BLI::rgba_f)
 CPP_TYPE_GETTER(string, std::string)
 CPP_TYPE_GETTER(GenericArrayRef, GenericArrayRef);
+CPP_TYPE_GETTER(GenericMutableArrayRef, GenericMutableArrayRef);
 
 #undef CPP_TYPE_GETTER
 
diff --git a/source/blender/blenkernel/intern/generic_array_ref.cc b/source/blender/blenkernel/intern/generic_array_ref.cc
index 6f9072acf68..65e47b0a6e7 100644
--- a/source/blender/blenkernel/intern/generic_array_ref.cc
+++ b/source/blender/blenkernel/intern/generic_array_ref.cc
@@ -9,20 +9,28 @@ namespace BKE {
 
 using BLI::Map;
 
-using TypeMapping = Map<const CPPType *, std::unique_ptr<ArrayRefCPPType>>;
+using ArrayRefTypeMapping = Map<const CPPType *, std::unique_ptr<ArrayRefCPPType>>;
+using MutableArrayRefTypeMapping = Map<const CPPType *, std::unique_ptr<MutableArrayRefCPPType>>;
 
-BLI_LAZY_INIT_STATIC(TypeMapping, get_mapping)
+BLI_LAZY_INIT_STATIC(ArrayRefTypeMapping, get_type_mapping)
 {
-  return TypeMapping{};
+  return ArrayRefTypeMapping{};
 }
 
-static std::mutex mapping_mutex;
+BLI_LAZY_INIT_STATIC(MutableArrayRefTypeMapping, get_mutable_type_mapping)
+{
+  return MutableArrayRefTypeMapping{};
+}
+
+static std::mutex map_mutex__immutable;
+static std::mutex map_mutex__mutable;
 
 ArrayRefCPPType &get_generic_array_ref_cpp_type(CPPType &base)
 {
-  std::lock_guard<std::mutex> lock(mapping_mutex);
+  std::lock_guard<std::mutex> lock(map_mutex__immutable);
+
+  ArrayRefTypeMapping &mapping = get_type_mapping();
 
-  TypeMapping &mapping = get_mapping();
   auto &type = mapping.lookup_or_add(&base, [&]() {
     ArrayRefCPPType *new_type = new ArrayRefCPPType(base);
     return std::unique_ptr<ArrayRefCPPType>(new_type);
@@ -30,6 +38,20 @@ ArrayRefCPPType &get_generic_array_ref_cpp_type(CPPType &base)
   return *type;
 }
 
+MutableArrayRefCPPType &get_generic_mutable_array_ref_cpp_type(CPPType &base)
+{
+  std::lock_guard<std::mutex> lock(map_mutex__mutable);
+
+  MutableArrayRefTypeMapping &mapping = get_mutable_type_mapping();
+
+  auto &type = mapping.lookup_or_add(&base, [&]() {
+    MutableArrayRefCPPType *new_type = new MutableArrayRefCPPType(base);
+    return std::unique_ptr<MutableArrayRefCPPType>(new_type);
+  });
+
+  return *type;
+}
+
 ArrayRefCPPType::ArrayRefCPPType(CPPType &base_type)
     : CPPType("GenericArrayRef for " + base_type.name(),
               get_cpp_type<GenericArrayRef>(),
@@ -38,4 +60,12 @@ ArrayRefCPPType::ArrayRefCPPType(CPPType &base_type)
 {
 }
 
+MutableArrayRefCPPType::MutableArrayRefCPPType(CPPType &base_type)
+    : CPPType("GenericMutableArrayRef for " + base_type.name(),
+              get_cpp_type<GenericMutableArrayRef>(),
+              MutableArrayRefCPPType::ConstructDefaultCB),
+      m_base_type(base_type)
+{
+}
+
 }  // namespace BKE
\ No newline at end of file