From e8210b476ccc2e6a4d1f1cc07fcfad3515d4d7a2 Mon Sep 17 00:00:00 2001
From: beder <jbeder@gmail.com>
Date: Sun, 11 Sep 2011 21:32:47 -0500
Subject: [PATCH] Started specialization for operator[] for integers

---
 include/yaml-cpp/node/detail/impl.h      | 57 ++++++++++++++++++------
 include/yaml-cpp/node/detail/node_data.h |  2 +
 src/node/detail/node_data.cpp            | 53 +++++++++++++++-------
 3 files changed, 81 insertions(+), 31 deletions(-)

diff --git a/include/yaml-cpp/node/detail/impl.h b/include/yaml-cpp/node/detail/impl.h
index 613e58d..752ea03 100644
--- a/include/yaml-cpp/node/detail/impl.h
+++ b/include/yaml-cpp/node/detail/impl.h
@@ -13,13 +13,43 @@ namespace YAML
 {
 	namespace detail
 	{
+		template<typename Key, typename Enable = void>
+		struct get_idx_helper {
+			static node *get(const Key& /* key */, shared_memory_holder /* pMemory */) {
+				return 0;
+			}
+		};
+
+		template<typename Key>
+		struct get_idx_helper<Key, typename boost::enable_if<boost::is_integral<Key> >::type> {
+			static node *get(const Key& key, shared_memory_holder pMemory) {
+				return 0;
+			}
+		};
+		
+		template<typename Key>
+		inline node *get_idx(const Key& key, shared_memory_holder pMemory) {
+			return get_idx_helper<Key>::get(key, pMemory);
+		}
+
 		// indexing
 		template<typename Key>
 		inline node& node_data::get(const Key& key, shared_memory_holder pMemory) const
 		{
-			if(m_type != NodeType::Map)
-				return pMemory->create_node();
-			
+			switch(m_type) {
+				case NodeType::Map:
+					break;
+				case NodeType::Undefined:
+				case NodeType::Null:
+					return pMemory->create_node();
+				case NodeType::Sequence:
+					if(node *pNode = get_idx(key, pMemory))
+						return *pNode;
+					return pMemory->create_node();
+				case NodeType::Scalar:
+					throw std::runtime_error("Can't call operator[] on a scalar");
+			}
+
 			for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) {
 				if(equals(*it->first, key, pMemory))
 					return *it->second;
@@ -31,20 +61,19 @@ namespace YAML
 		template<typename Key>
 		inline node& node_data::get(const Key& key, shared_memory_holder pMemory)
 		{
-			// TODO: check if 'key' is index-like, and we're a sequence
-			
 			switch(m_type) {
-				case NodeType::Undefined:
-				case NodeType::Null:
-				case NodeType::Scalar:
-					m_type = NodeType::Map;
-					m_map.clear();
-					break;
-				case NodeType::Sequence:
-					convert_sequence_to_map(pMemory);
-					break;
 				case NodeType::Map:
 					break;
+				case NodeType::Undefined:
+				case NodeType::Null:
+				case NodeType::Sequence:
+					if(node *pNode = get_idx(key, pMemory))
+						return *pNode;
+					
+					convert_to_map(pMemory);
+					break;
+				case NodeType::Scalar:
+					throw std::runtime_error("Can't call operator[] on a scalar");
 			}
 			
 			for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) {
diff --git a/include/yaml-cpp/node/detail/node_data.h b/include/yaml-cpp/node/detail/node_data.h
index 232116d..aab8fc0 100644
--- a/include/yaml-cpp/node/detail/node_data.h
+++ b/include/yaml-cpp/node/detail/node_data.h
@@ -64,7 +64,9 @@ namespace YAML
 
 			void reset_sequence();
 			void reset_map();
+			
 			void insert_map_pair(node& key, node& value);
+			void convert_to_map(shared_memory_holder pMemory);
 			void convert_sequence_to_map(shared_memory_holder pMemory);
 			
 			template<typename T>
diff --git a/src/node/detail/node_data.cpp b/src/node/detail/node_data.cpp
index ba3bb04..f5e8ea8 100644
--- a/src/node/detail/node_data.cpp
+++ b/src/node/detail/node_data.cpp
@@ -163,16 +163,18 @@ namespace YAML
 
 		void node_data::insert(node& key, node& value, shared_memory_holder pMemory)
 		{
-			if(m_type == NodeType::Undefined || m_type == NodeType::Null) {
-				m_type = NodeType::Map;
-				reset_map();
-			} else if(m_type == NodeType::Sequence) {
-				convert_sequence_to_map(pMemory);
+			switch(m_type) {
+				case NodeType::Map:
+					break;
+				case NodeType::Undefined:
+				case NodeType::Null:
+				case NodeType::Sequence:
+					convert_to_map(pMemory);
+					break;
+				case NodeType::Scalar:
+					throw std::runtime_error("Can't call operator[] on a scalar");
 			}
 
-			if(m_type != NodeType::Map)
-				throw std::runtime_error("Can't insert into a non-map node");
-
 			insert_map_pair(key, value);
 		}
 
@@ -193,17 +195,15 @@ namespace YAML
 		node& node_data::get(node& key, shared_memory_holder pMemory)
 		{
 			switch(m_type) {
-				case NodeType::Undefined:
-				case NodeType::Null:
-				case NodeType::Scalar:
-					m_type = NodeType::Map;
-					reset_map();
-					break;
-				case NodeType::Sequence:
-					convert_sequence_to_map(pMemory);
-					break;
 				case NodeType::Map:
 					break;
+				case NodeType::Undefined:
+				case NodeType::Null:
+				case NodeType::Sequence:
+					convert_to_map(pMemory);
+					break;
+				case NodeType::Scalar:
+					throw std::runtime_error("Can't call operator[] on a scalar");
 			}
 
 			for(node_map::const_iterator it=m_map.begin();it!=m_map.end();++it) {
@@ -250,6 +250,25 @@ namespace YAML
 				m_undefinedPairs.push_back(kv_pair(&key, &value));
 		}
 
+		void node_data::convert_to_map(shared_memory_holder pMemory)
+		{
+			switch(m_type) {
+				case NodeType::Undefined:
+				case NodeType::Null:
+					reset_map();
+					m_type = NodeType::Map;
+					break;
+				case NodeType::Sequence:
+					convert_sequence_to_map(pMemory);
+					break;
+				case NodeType::Map:
+					break;
+				case NodeType::Scalar:
+					assert(false);
+					break;
+			}
+		}
+
 		void node_data::convert_sequence_to_map(shared_memory_holder pMemory)
 		{
 			assert(m_type == NodeType::Sequence);