[Bf-blender-cvs] [8667a871347] functions: Revert "try storing values per input differently"

[Jacques Lucke]

Commit: 8667a8713474c4c90a74b3473d85542aafd1fd1e
Author: Jacques Lucke
Date:   Sun Jan 26 11:06:54 2020 +0100
Branches: functions
https://developer.blender.org/rB8667a8713474c4c90a74b3473d85542aafd1fd1e

Revert "try storing values per input differently"

This reverts commit fee675ffe08f1c92ee3d181fe4350061850511f1.

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

M	source/blender/functions/intern/multi_functions/network.cc

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

diff --git a/source/blender/functions/intern/multi_functions/network.cc b/source/blender/functions/intern/multi_functions/network.cc
index 367cc341179..8f337f4ad16 100644
--- a/source/blender/functions/intern/multi_functions/network.cc
+++ b/source/blender/functions/intern/multi_functions/network.cc
@@ -6,40 +6,18 @@ namespace FN {
 
 using BLI::ArrayAllocator;
 
-namespace InputValueType {
-enum Enum {
-  None,
-  VectorArray,
-  Array,
-  VirtualList,
-  VirtualListList,
-};
-}
-
-struct InputValue {
-  InputValueType::Enum type;
-
-  union Value {
-    Value()
-    {
-    }
-
-    GenericVectorArray *vector_array;
-    GenericMutableArrayRef array_ref;
-    GenericVirtualListRef virtual_list_ref;
-    GenericVirtualListListRef virtual_list_list_ref;
-  } data;
-};
-
 class MF_EvaluateNetwork_Storage {
  private:
-  MonotonicAllocator<256> m_monotonic_allocator;
+  MonotonicAllocator<256> m_single_allocator;
   IndexMask m_mask;
   ArrayAllocator &m_array_allocator;
   Vector<GenericVectorArray *> m_vector_arrays;
   Vector<GenericMutableArrayRef> m_arrays;
   Vector<GenericMutableArrayRef> m_single_element_arrays;
-  Map<uint, InputValue *> m_value_by_input;
+  Map<uint, GenericVectorArray *> m_vector_array_for_inputs;
+  Map<uint, GenericVirtualListRef> m_virtual_list_for_inputs;
+  Map<uint, GenericVirtualListListRef> m_virtual_list_list_for_inputs;
+  Map<uint, GenericMutableArrayRef> m_array_ref_for_inputs;
 
  public:
   MF_EvaluateNetwork_Storage(IndexMask mask, ArrayAllocator &array_allocator)
@@ -78,7 +56,7 @@ class MF_EvaluateNetwork_Storage {
 
   GenericMutableArrayRef allocate_array__single_element(const CPPType &type)
   {
-    void *buffer = m_monotonic_allocator.allocate(type.size(), type.alignment());
+    void *buffer = m_single_allocator.allocate(type.size(), type.alignment());
     GenericMutableArrayRef array(type, buffer, 1);
     m_single_element_arrays.append(array);
     return array;
@@ -150,67 +128,55 @@ class MF_EvaluateNetwork_Storage {
 
   void set_array_ref(const MFInputSocket &socket, GenericMutableArrayRef array)
   {
-    InputValue *input_value = m_monotonic_allocator.allocate<InputValue>();
-    input_value->type = InputValueType::Array;
-    new (&input_value->data.array_ref) GenericMutableArrayRef(array);
-    m_value_by_input.add_new(socket.id(), input_value);
+    m_array_ref_for_inputs.add_new(socket.id(), array);
   }
 
   void set_virtual_list(const MFInputSocket &socket, GenericVirtualListRef list)
   {
-    InputValue *input_value = m_monotonic_allocator.allocate<InputValue>();
-    input_value->type = InputValueType::VirtualList;
-    new (&input_value->data.virtual_list_ref) GenericVirtualListRef(list);
-    m_value_by_input.add_new(socket.id(), input_value);
+    m_virtual_list_for_inputs.add_new(socket.id(), list);
   }
 
   void set_virtual_list_list(const MFInputSocket &socket, GenericVirtualListListRef list)
   {
-    InputValue *input_value = m_monotonic_allocator.allocate<InputValue>();
-    input_value->type = InputValueType::VirtualListList;
-    new (&input_value->data.virtual_list_list_ref) GenericVirtualListListRef(list);
-    m_value_by_input.add_new(socket.id(), input_value);
+    m_virtual_list_list_for_inputs.add_new(socket.id(), list);
   }
 
   void set_vector_array(const MFInputSocket &socket, GenericVectorArray &vector_array)
   {
-    InputValue *input_value = m_monotonic_allocator.allocate<InputValue>();
-    input_value->type = InputValueType::VectorArray;
-    input_value->data.vector_array = &vector_array;
-    m_value_by_input.add_new(socket.id(), input_value);
+    m_vector_array_for_inputs.add_new(socket.id(), &vector_array);
   }
 
   GenericVirtualListRef get_virtual_list(const MFInputSocket &socket) const
   {
-    InputValue *input_value = m_value_by_input.lookup(socket.id());
-    BLI_assert(input_value->type == InputValueType::VirtualList);
-    return input_value->data.virtual_list_ref;
+    return m_virtual_list_for_inputs.lookup(socket.id());
   }
 
   GenericVirtualListListRef get_virtual_list_list(const MFInputSocket &socket) const
   {
-    InputValue *input_value = m_value_by_input.lookup(socket.id());
-    BLI_assert(input_value->type == InputValueType::VirtualListList);
-    return input_value->data.virtual_list_list_ref;
+    return m_virtual_list_list_for_inputs.lookup(socket.id());
   }
 
   GenericVectorArray &get_vector_array(const MFInputSocket &socket) const
   {
-    InputValue *input_value = m_value_by_input.lookup(socket.id());
-    BLI_assert(input_value->type == InputValueType::VectorArray);
-    return *input_value->data.vector_array;
+    return *m_vector_array_for_inputs.lookup(socket.id());
   }
 
   GenericMutableArrayRef get_array_ref(const MFInputSocket &socket) const
   {
-    InputValue *input_value = m_value_by_input.lookup(socket.id());
-    BLI_assert(input_value->type == InputValueType::Array);
-    return input_value->data.array_ref;
+    return m_array_ref_for_inputs.lookup(socket.id());
   }
 
   bool input_is_computed(const MFInputSocket &socket) const
   {
-    return m_value_by_input.contains(socket.id());
+    switch (socket.data_type().category()) {
+      case MFDataType::Single:
+        return m_virtual_list_for_inputs.contains(socket.id());
+      case MFDataType::Vector:
+        return m_virtual_list_list_for_inputs.contains(socket.id()) ||
+               m_vector_array_for_inputs.contains(socket.id());
+    }
+    BLI_assert(false);
+    return false;
   }
 
   bool function_input_has_single_element(const MFInputSocket &socket) const
@@ -219,13 +185,13 @@ class MF_EvaluateNetwork_Storage {
     MFParamType param_type = socket.param_type();
     switch (param_type.type()) {
       case MFParamType::SingleInput:
-        return this->get_virtual_list(socket).is_single_element();
+        return m_virtual_list_for_inputs.lookup(socket.id()).is_single_element();
       case MFParamType::VectorInput:
-        return this->get_virtual_list_list(socket).is_single_list();
+        return m_virtual_list_list_for_inputs.lookup(socket.id()).is_single_list();
       case MFParamType::MutableSingle:
-        return this->get_array_ref(socket).size() == 1;
+        return m_array_ref_for_inputs.lookup(socket.id()).size() == 1;
       case MFParamType::MutableVector:
-        return this->get_vector_array(socket).size() == 1;
+        return m_vector_array_for_inputs.lookup(socket.id())->size() == 1;
       case MFParamType::SingleOutput:
       case MFParamType::VectorOutput:
         break;