Reimplement merge key support in detail::node.

Author: Ortham

include/yaml-cpp/node/detail/node.h

@@ -112,18 +112,48 @@ class node : private boost::noncopyable {
     value.add_dependency(*this);
   }
 
+  template <typename Key>
+  inline node* GetValueFromMergeKey(const Key& key, node* currentValue,
+                                    shared_memory_holder pMemory) const {
+    node* mergeValue =
+        static_cast<const node_ref&>(*m_pRef).get(to_value("<<"), pMemory);
+    if (mergeValue) {
+      if (mergeValue->type() == NodeType::Map) {
+        return &mergeValue->get(key, pMemory);
+      } else if (mergeValue->type() == NodeType::Sequence) {
+        for (const_node_iterator it = mergeValue->begin();
+             it != mergeValue->end(); ++it) {
+          if (it->pNode && it->pNode->type() == NodeType::Map) {
+            node* value = it->pNode->get(key, pMemory);
+            if (value && value->type() != NodeType::Undefined) {
+              return value;
+            }
+          }
+        }
+      }
+    }
+    return currentValue;
+  }
+
   // indexing
   template <typename Key>
   node* get(const Key& key, shared_memory_holder pMemory) const {
     // NOTE: this returns a non-const node so that the top-level Node can wrap
     // it, and returns a pointer so that it can be NULL (if there is no such
     // key).
-    return static_cast<const node_ref&>(*m_pRef).get(key, pMemory);
+    node* value = static_cast<const node_ref&>(*m_pRef).get(key, pMemory);
+    if (!value || value->type() == NodeType::Undefined) {
+      return GetValueFromMergeKey(key, value, pMemory);
+    }
+    return value;
   }
   template <typename Key>
   node& get(const Key& key, shared_memory_holder pMemory) {
     node& value = m_pRef->get(key, pMemory);
     value.add_dependency(*this);
+    if (value.type() == NodeType::Undefined) {
+      return *GetValueFromMergeKey(key, &value, pMemory);
+    }
     return value;
   }
   template <typename Key>

include/yaml-cpp/node/impl.h

@@ -369,8 +369,8 @@ inline const Node Node::operator[](const Key& key) const {
   EnsureNodeExists();
   detail::node* value = static_cast<const detail::node&>(*m_pNode)
                             .get(detail::to_value(key), m_pMemory);
-  if (!value || value->type() == NodeType::Undefined) {
-    return GetValueFromMergeKey(key, value);
+  if (!value) {
+    return Node(ZombieNode);
   }
   return Node(*value, m_pMemory);
 }
@@ -381,37 +381,9 @@ inline Node Node::operator[](const Key& key) {
     throw InvalidNode();
   EnsureNodeExists();
   detail::node& value = m_pNode->get(detail::to_value(key), m_pMemory);
-  if (value.type() == NodeType::Undefined) {
-    return GetValueFromMergeKey(key, &value);
-  }
   return Node(value, m_pMemory);
 }
 
-template <typename Key>
-inline Node Node::GetValueFromMergeKey(const Key& key,
-                                       detail::node* currentValue) const {
-  detail::node* mergeValue = static_cast<const detail::node&>(*m_pNode)
-                                 .get(detail::to_value("<<"), m_pMemory);
-  if (mergeValue && mergeValue->type() != NodeType::Undefined) {
-    Node mergeNode(*mergeValue, m_pMemory);
-    // Merge keys are used with maps and sequences of maps. Aliases may be used,
-    // but yaml-cpp resolves them automatically.
-    if (mergeNode.IsMap()) {
-      return mergeNode[key];
-    } else if (mergeNode.IsSequence()) {
-      for (const_iterator it = mergeNode.begin(); it != mergeNode.end(); ++it) {
-        if (it->IsMap() && (*it)[key]) {
-          return (*it)[key];
-        }
-      }
-    }
-  }
-  if (!currentValue) {
-    return Node(ZombieNode);
-  }
-  return Node(*currentValue, m_pMemory);
-}
-
 template <typename Key>
 inline bool Node::remove(const Key& key) {
   if (!m_isValid)