Added force_insert for mapping nodes that doesn't check to see if the key exists already (so it could duplicate keys)

include/yaml-cpp/exceptions.h

@@ -61,6 +61,7 @@ namespace YAML
 		const char * const BAD_DEREFERENCE        = "bad dereference";
         const char * const BAD_SUBSCRIPT          = "operator[] call on a scalar";
         const char * const BAD_PUSHBACK           = "appending to a non-sequence";
+        const char * const BAD_INSERT             = "inserting in a non-convertible-to-map";
 		
 		const char * const UNMATCHED_GROUP_TAG    = "unmatched group tag";
 		const char * const UNEXPECTED_END_SEQ     = "unexpected end sequence token";
@@ -178,6 +179,12 @@ namespace YAML
 		: RepresentationException(Mark::null(), ErrorMsg::BAD_PUSHBACK) {}
 	};
 	
+	class BadInsert: public RepresentationException {
+	public:
+		BadInsert()
+		: RepresentationException(Mark::null(), ErrorMsg::BAD_INSERT) {}
+	};
+
 	class EmitterException: public Exception {
 	public:
 		EmitterException(const std::string& msg_)

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

@@ -118,6 +118,27 @@ namespace YAML
 			
 			return false;
 		}
+        
+        // map
+        template<typename Key, typename Value>
+        inline void node_data::force_insert(const Key& key, const Value& value, shared_memory_holder 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 BadInsert();
+			}
+			
+			node& k = convert_to_node(key, pMemory);
+			node& v = convert_to_node(value, pMemory);
+			insert_map_pair(k, v);
+        }
 
 		template<typename T>
 		inline bool node_data::equals(node& node, const T& rhs, shared_memory_holder pMemory)

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

@@ -115,6 +115,10 @@ namespace YAML
 			}
 			bool remove(node& key, shared_memory_holder pMemory) { return m_pRef->remove(key, pMemory); }
 
+            // map
+            template<typename Key, typename Value>
+            void force_insert(const Key& key, const Value& value, shared_memory_holder pMemory){ m_pRef->force_insert(key, value, pMemory); }
+
 		private:
 			shared_node_ref m_pRef;
 			typedef std::set<node *> nodes;

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

@@ -56,6 +56,10 @@ namespace YAML
 			node& get(node& key, shared_memory_holder pMemory) const;
 			node& get(node& key, shared_memory_holder pMemory);
 			bool remove(node& key, shared_memory_holder pMemory);
+            
+            // map
+            template<typename Key, typename Value>
+            void force_insert(const Key& key, const Value& value, shared_memory_holder pMemory);
 			
 		public:
 			static std::string empty_scalar;

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

@@ -55,6 +55,10 @@ namespace YAML
 			node& get(node& key, shared_memory_holder pMemory) const { return static_cast<const node_data&>(*m_pData).get(key, pMemory); }
 			node& get(node& key, shared_memory_holder pMemory) { return m_pData->get(key, pMemory); }
 			bool remove(node& key, shared_memory_holder pMemory) { return m_pData->remove(key, pMemory); }
+            
+            // map
+            template<typename Key, typename Value>
+            void force_insert(const Key& key, const Value& value, shared_memory_holder pMemory) { m_pData->force_insert(key, value, pMemory); }
 
 		private:
 			shared_node_data m_pData;

include/yaml-cpp/node/impl.h

@@ -358,9 +358,16 @@ namespace YAML
 		key.EnsureNodeExists();
 		return m_pNode->remove(*key.m_pNode, m_pMemory);
 	}
+    
+    // map
+    template<typename Key, typename Value>
+    inline void Node::force_insert(const Key& key, const Value& value)
+    {
+        EnsureNodeExists();
+		m_pNode->force_insert(detail::to_value(key), detail::to_value(value), m_pMemory);
+    }
 
 	// free functions
-
 	inline bool operator==(const Node& lhs, const Node& rhs)
 	{
 		return lhs.is(rhs);

include/yaml-cpp/node/node.h

@@ -78,6 +78,10 @@ namespace YAML
 		const Node operator[](const Node& key) const;
 		Node operator[](const Node& key);
 		bool remove(const Node& key);
+        
+        // map
+        template<typename Key, typename Value>
+        void force_insert(const Key& key, const Value& value);
 
 	private:
 		explicit Node(detail::node& node, detail::shared_memory_holder pMemory);