Cleanup: move methods out of field classes

This makes it easier to scan through the classes and simplifies
testing the compile time impact of having these methods in the header.

1 files changed, 113 insertions, 83 deletions

diff --git a/source/blender/functions/FN_field.hh b/source/blender/functions/FN_field.hh
index 3ce0993da59..eeb97946029 100644
--- a/source/blender/functions/FN_field.hh
+++ b/source/blender/functions/FN_field.hh
@@ -77,29 +77,15 @@ class FieldNode {
   bool depends_on_input_;
 
  public:
-  FieldNode(bool is_input, bool depends_on_input)
-      : is_input_(is_input), depends_on_input_(depends_on_input)
-  {
-  }
+  FieldNode(bool is_input, bool depends_on_input);
 
   virtual ~FieldNode() = default;
 
   virtual const CPPType &output_cpp_type(int output_index) const = 0;
 
-  bool is_input() const
-  {
-    return is_input_;
-  }
-
-  bool is_operation() const
-  {
-    return !is_input_;
-  }
-
-  bool depends_on_input() const
-  {
-    return depends_on_input_;
-  }
+  bool is_input() const;
+  bool is_operation() const;
+  bool depends_on_input() const;
 
   /**
    * Invoke callback for every field input. It might be called multiple times for the same input.
@@ -107,25 +93,8 @@ class FieldNode {
    */
   virtual void foreach_field_input(FunctionRef<void(const FieldInput &)> foreach_fn) const = 0;
 
-  virtual uint64_t hash() const
-  {
-    return get_default_hash(this);
-  }
-
-  friend bool operator==(const FieldNode &a, const FieldNode &b)
-  {
-    return a.is_equal_to(b);
-  }
-
-  friend bool operator!=(const FieldNode &a, const FieldNode &b)
-  {
-    return !(a == b);
-  }
-
-  virtual bool is_equal_to(const FieldNode &other) const
-  {
-    return this == &other;
-  }
+  virtual uint64_t hash() const;
+  virtual bool is_equal_to(const FieldNode &other) const;
 };
 
 /**
@@ -245,32 +214,10 @@ class FieldOperation : public FieldNode {
   FieldOperation(std::unique_ptr<const MultiFunction> function, Vector<GField> inputs = {});
   FieldOperation(const MultiFunction &function, Vector<GField> inputs = {});
 
-  Span<GField> inputs() const
-  {
-    return inputs_;
-  }
-
-  const MultiFunction &multi_function() const
-  {
-    return *function_;
-  }
-
-  const CPPType &output_cpp_type(int output_index) const override
-  {
-    int output_counter = 0;
-    for (const int param_index : function_->param_indices()) {
-      MFParamType param_type = function_->param_type(param_index);
-      if (param_type.is_output()) {
-        if (output_counter == output_index) {
-          return param_type.data_type().single_type();
-        }
-        output_counter++;
-      }
-    }
-    BLI_assert_unreachable();
-    return CPPType::get<float>();
-  }
+  Span<GField> inputs() const;
+  const MultiFunction &multi_function() const;
 
+  const CPPType &output_cpp_type(int output_index) const override;
   void foreach_field_input(FunctionRef<void(const FieldInput &)> foreach_fn) const override;
 };
 
@@ -295,28 +242,11 @@ class FieldInput : public FieldNode {
                                                 IndexMask mask,
                                                 ResourceScope &scope) const = 0;
 
-  virtual std::string socket_inspection_name() const
-  {
-    return debug_name_;
-  }
-
-  blender::StringRef debug_name() const
-  {
-    return debug_name_;
-  }
-
-  const CPPType &cpp_type() const
-  {
-    return *type_;
-  }
-
-  const CPPType &output_cpp_type(int output_index) const override
-  {
-    BLI_assert(output_index == 0);
-    UNUSED_VARS_NDEBUG(output_index);
-    return *type_;
-  }
+  virtual std::string socket_inspection_name() const;
+  blender::StringRef debug_name() const;
+  const CPPType &cpp_type() const;
 
+  const CPPType &output_cpp_type(int output_index) const override;
   void foreach_field_input(FunctionRef<void(const FieldInput &)> foreach_fn) const override;
 };
 
@@ -493,4 +423,104 @@ class IndexFieldInput final : public FieldInput {
                                         ResourceScope &scope) const final;
 };
 
+/* --------------------------------------------------------------------
+ * #FieldNode inline methods.
+ */
+
+inline FieldNode::FieldNode(bool is_input, bool depends_on_input)
+    : is_input_(is_input), depends_on_input_(depends_on_input)
+{
+}
+
+inline bool FieldNode::is_input() const
+{
+  return is_input_;
+}
+
+inline bool FieldNode::is_operation() const
+{
+  return !is_input_;
+}
+
+inline bool FieldNode::depends_on_input() const
+{
+  return depends_on_input_;
+}
+
+inline uint64_t FieldNode::hash() const
+{
+  return get_default_hash(this);
+}
+
+inline bool FieldNode::is_equal_to(const FieldNode &other) const
+{
+  return this == &other;
+}
+
+inline bool operator==(const FieldNode &a, const FieldNode &b)
+{
+  return a.is_equal_to(b);
+}
+
+inline bool operator!=(const FieldNode &a, const FieldNode &b)
+{
+  return !(a == b);
+}
+
+/* --------------------------------------------------------------------
+ * #FieldOperation inline methods.
+ */
+
+inline Span<GField> FieldOperation::inputs() const
+{
+  return inputs_;
+}
+
+inline const MultiFunction &FieldOperation::multi_function() const
+{
+  return *function_;
+}
+
+inline const CPPType &FieldOperation::output_cpp_type(int output_index) const
+{
+  int output_counter = 0;
+  for (const int param_index : function_->param_indices()) {
+    MFParamType param_type = function_->param_type(param_index);
+    if (param_type.is_output()) {
+      if (output_counter == output_index) {
+        return param_type.data_type().single_type();
+      }
+      output_counter++;
+    }
+  }
+  BLI_assert_unreachable();
+  return CPPType::get<float>();
+}
+
+/* --------------------------------------------------------------------
+ * #FieldInput inline methods.
+ */
+
+inline std::string FieldInput::socket_inspection_name() const
+{
+  return debug_name_;
+}
+
+inline StringRef FieldInput::debug_name() const
+{
+  return debug_name_;
+}
+
+inline const CPPType &FieldInput::cpp_type() const
+{
+  return *type_;
+}
+
+inline const CPPType &FieldInput::output_cpp_type(int output_index) const
+{
+  BLI_assert(output_index == 0);
+  UNUSED_VARS_NDEBUG(output_index);
+  return *type_;
+}
+
 }  // namespace blender::fn