[core] support component ref finder

Author: yxping

weex_core/Source/core/data_render/parser.cc

@@ -33,6 +33,7 @@ namespace data_render {
 
 static const char kCreateComponentRecursively[] = "__createComponentRecursively";
 static const char kCreateBodyFunction[] = "main";
+static const char kAttrRepeatControl[] = "[[repeat]]";
 
 struct ASTParser final {
   /* State */
@@ -60,6 +61,14 @@ struct ASTParser final {
     }
   }
 
+  inline void SetAttributeStatement(std::vector<Handle<Expression>> args,
+                                    Handle<BlockStatement>& block) {
+    Handle<Expression> set_attr_func_id = factory_->NewIdentifier("setAttr");
+    Handle<CallExpression> call_func =
+        factory_->NewCallExpression(set_attr_func_id, args);
+    block->PushExpression(call_func);
+  }
+
     void AddAppendChildCall(json11::Json& json, Handle<Identifier>& parent_identifier,
                           Handle<Identifier>& child_identifier) {
     Handle<BlockStatement> statement = stacks_[stacks_.size() - 1];
@@ -580,6 +589,12 @@ struct ASTParser final {
       std::vector<Handle<Expression>> control_exprs;
       if (control.is_object()) {
         control_exprs = ParseControl(control);
+        if (control["repeat"].is_string()) {
+            SetAttributeStatement({child_identifier,
+                                   factory_->NewStringConstant(kAttrRepeatControl),
+                                   factory_->NewStringConstant("")},
+                                  stacks_[stacks_.size() - 1]);
+        }
       }
       json11::Json node_id = json["nodeId"];
       json11::Json tag_name = json["tagName"];
@@ -655,22 +670,12 @@ struct ASTParser final {
         for (auto it = items.begin(); it != items.end(); ++it) {
           const auto& key = it->first;
           const auto& value = it->second;
-          std::vector<Handle<Expression>> args;
-          args.push_back(child_identifier);
-          args.push_back(factory_->NewStringConstant(key));
-          if (value.is_string()) {
-            args.push_back(
-                factory_->NewStringConstant(value.string_value()));
-          } else {
-            args.push_back(ParseBindingExpression(value));
-          }
-
-          Handle<Expression> set_attr_func_id =
-              factory_->NewIdentifier("setAttr");
-          Handle<CallExpression> call_func =
-              factory_->NewCallExpression(set_attr_func_id, args);
-          Handle<BlockStatement> statement = stacks_[stacks_.size() - 1];
-          statement->PushExpression(call_func);
+          SetAttributeStatement(
+              {child_identifier, factory_->NewStringConstant(key),
+               value.is_string()
+                   ? factory_->NewStringConstant(value.string_value())
+                   : ParseBindingExpression(value)},
+              stacks_[stacks_.size() - 1]);
         }
       }
 

weex_core/Source/core/data_render/vnode/vcomponent.cc

@@ -86,6 +86,40 @@ static bool Equals(Value a, Value b) {
   return true;
 }
 
+static void BuildRefsInner(
+    std::unordered_map<std::string, VComponent::VNodeRefs> &ref_map,
+    VNode *node, bool in_for_loop) {
+  if (!node->ref().empty()) {
+    VComponent::VNodeRef ref;
+    ref.insert({"ref", node->render_object_ref()});
+    auto it = ref_map.find(node->ref());
+    if (it != ref_map.end()) {
+      if (!in_for_loop) {
+        return;
+      }
+      it->second.push_back(ref);
+    } else {
+      VComponent::VNodeRefs refs;
+      refs.push_back(ref);
+      ref_map.insert({node->ref(), refs});
+    }
+  }
+  if (node->child_list()->size() > 0 && !node->IsVirtualComponent()) {
+    if (node->attributes()->find("[[repeat]]") != node->attributes()->end()) {
+      in_for_loop = true;
+    }
+    for (auto it = node->child_list()->begin(); it != node->child_list()->end();
+         it++) {
+      BuildRefsInner(ref_map, *it, in_for_loop);
+    }
+  }
+}
+
+void VComponent::BuildRefMap() {
+  ref_map_.clear();
+  BuildRefsInner(ref_map_, root_vnode(), false);
+}
+
 bool VComponent::Equal(VComponent *old_component) {
   VComponent *new_component = this;
   if (old_component == new_component) return true;
@@ -170,8 +204,10 @@ void VComponent::TravelVComponentsWithFunc(TravelTreeFunc func, VNode *root) {
 
 void VComponent::DispatchCreated() {
   if (has_dispatch_created_) return;
+  BuildRefMap();
   if (listener_) {
-    listener_->OnCreated(this, ValueTo<Table>(&data_), ValueTo<Table>(&props_));
+    listener_->OnCreated(this, ValueTo<Table>(&data_), ValueTo<Table>(&props_),
+                         ref_map_);
   }
   TravelVComponentsWithFunc(&VComponent::DispatchCreated, root_vnode());
   has_dispatch_created_ = true;
@@ -183,6 +219,7 @@ void VComponent::DispatchUpdated() {
     return;
   }
   if (!is_dirty_) return;
+  BuildRefMap();
   if (listener_) {
     listener_->OnUpdated(this, ValueTo<Table>(&updated_props_));
   }

weex_core/Source/core/data_render/vnode/vcomponent.h

@@ -28,11 +28,16 @@ namespace core {
 namespace data_render {
 class VComponent : public VNode {
  public:
+  typedef std::unordered_map<std::string, std::string> VNodeRef;
+  typedef std::vector<std::unordered_map<std::string, std::string>> VNodeRefs;
   class LifecycleListener {
    public:
-    virtual void OnCreated(VComponent* component, Table* data,
-                           Table* props) = 0;
+    virtual void OnCreated(
+        VComponent* component, Table* data, Table* props,
+        const std::unordered_map<std::string, VNodeRefs>& ref_map) = 0;
     virtual void OnUpdated(VComponent* component, Table* props) = 0;
+    virtual void OnEvent(VComponent* component, const std::string& func,
+                         Array* params) = 0;
     virtual void OnDestroyed(VComponent* component) = 0;
   };
   VComponent(ExecState* exec_state, int template_id, const std::string& name,
@@ -71,6 +76,7 @@ class VComponent : public VNode {
   typedef void (VComponent::*TravelTreeFunc)();
   void TravelVComponentsWithFunc(TravelTreeFunc func, VNode* root);
 
+  void BuildRefMap();
   bool Equal(VComponent* old_component);
   void DispatchAttachedToParent() override;
   void DispatchDetachedFromParent() override;
@@ -90,7 +96,7 @@ class VComponent : public VNode {
   Value props_;
   Value updated_props_;
   std::unique_ptr<LifecycleListener> listener_;
-  std::unordered_map<std::string, VNode*> refs_;
+  std::unordered_map<std::string, VNodeRefs> ref_map_;
   std::unique_ptr<VNode> old_root_vnode_;
   std::unique_ptr<VNode> root_vnode_;
   ExecState* exec_state_;

weex_core/Source/core/data_render/vnode/vnode.h

@@ -31,9 +31,6 @@ namespace data_render {
 class VComponent;
 class Value;
 
-typedef std::function<void()> OnAttachedListener;
-typedef std::function<void()> OnDettachedListener;
-
 class VNode {
  public:
   VNode(const std::string &tag_name, const std::string &node_id,