1 #ifndef NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 2 #define NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 3 4 #if defined(_MSC_VER) || \ 5 (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 6 (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 7 #pragma once 8 #endif 9 10 #include "yaml-cpp/node/detail/node.h" 11 #include "yaml-cpp/node/detail/node_data.h" 12 13 #include <algorithm> 14 #include <type_traits> 15 16 namespace YAML { 17 namespace detail { 18 template <typename Key, typename Enable = void> 19 struct get_idx { getget_idx20 static node* get(const std::vector<node*>& /* sequence */, 21 const Key& /* key */, shared_memory_holder /* pMemory */) { 22 return nullptr; 23 } 24 }; 25 26 template <typename Key> 27 struct get_idx<Key, 28 typename std::enable_if<std::is_unsigned<Key>::value && 29 !std::is_same<Key, bool>::value>::type> { 30 static node* get(const std::vector<node*>& sequence, const Key& key, 31 shared_memory_holder /* pMemory */) { 32 return key < sequence.size() ? sequence[key] : nullptr; 33 } 34 35 static node* get(std::vector<node*>& sequence, const Key& key, 36 shared_memory_holder pMemory) { 37 if (key > sequence.size() || (key > 0 && !sequence[key - 1]->is_defined())) 38 return nullptr; 39 if (key == sequence.size()) 40 sequence.push_back(&pMemory->create_node()); 41 return sequence[key]; 42 } 43 }; 44 45 template <typename Key> 46 struct get_idx<Key, typename std::enable_if<std::is_signed<Key>::value>::type> { 47 static node* get(const std::vector<node*>& sequence, const Key& key, 48 shared_memory_holder pMemory) { 49 return key >= 0 ? get_idx<std::size_t>::get( 50 sequence, static_cast<std::size_t>(key), pMemory) 51 : nullptr; 52 } 53 static node* get(std::vector<node*>& sequence, const Key& key, 54 shared_memory_holder pMemory) { 55 return key >= 0 ? get_idx<std::size_t>::get( 56 sequence, static_cast<std::size_t>(key), pMemory) 57 : nullptr; 58 } 59 }; 60 61 template <typename Key, typename Enable = void> 62 struct remove_idx { 63 static bool remove(std::vector<node*>&, const Key&, std::size_t&) { 64 return false; 65 } 66 }; 67 68 template <typename Key> 69 struct remove_idx< 70 Key, typename std::enable_if<std::is_unsigned<Key>::value && 71 !std::is_same<Key, bool>::value>::type> { 72 73 static bool remove(std::vector<node*>& sequence, const Key& key, 74 std::size_t& seqSize) { 75 if (key >= sequence.size()) { 76 return false; 77 } else { 78 sequence.erase(sequence.begin() + key); 79 if (seqSize > key) { 80 --seqSize; 81 } 82 return true; 83 } 84 } 85 }; 86 87 template <typename Key> 88 struct remove_idx<Key, 89 typename std::enable_if<std::is_signed<Key>::value>::type> { 90 91 static bool remove(std::vector<node*>& sequence, const Key& key, 92 std::size_t& seqSize) { 93 return key >= 0 ? remove_idx<std::size_t>::remove( 94 sequence, static_cast<std::size_t>(key), seqSize) 95 : false; 96 } 97 }; 98 99 template <typename T> 100 inline bool node::equals(const T& rhs, shared_memory_holder pMemory) { 101 T lhs; 102 if (convert<T>::decode(Node(*this, pMemory), lhs)) { 103 return lhs == rhs; 104 } 105 return false; 106 } 107 108 inline bool node::equals(const char* rhs, shared_memory_holder pMemory) { 109 std::string lhs; 110 if (convert<std::string>::decode(Node(*this, std::move(pMemory)), lhs)) { 111 return lhs == rhs; 112 } 113 return false; 114 } 115 116 // indexing 117 template <typename Key> 118 inline node* node_data::get(const Key& key, 119 shared_memory_holder pMemory) const { 120 switch (m_type) { 121 case NodeType::Map: 122 break; 123 case NodeType::Undefined: 124 case NodeType::Null: 125 return nullptr; 126 case NodeType::Sequence: 127 if (node* pNode = get_idx<Key>::get(m_sequence, key, pMemory)) 128 return pNode; 129 return nullptr; 130 case NodeType::Scalar: 131 throw BadSubscript(m_mark, key); 132 } 133 134 auto it = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) { 135 return m.first->equals(key, pMemory); 136 }); 137 138 return it != m_map.end() ? it->second : nullptr; 139 } 140 141 template <typename Key> 142 inline node& node_data::get(const Key& key, shared_memory_holder pMemory) { 143 switch (m_type) { 144 case NodeType::Map: 145 break; 146 case NodeType::Undefined: 147 case NodeType::Null: 148 case NodeType::Sequence: 149 if (node* pNode = get_idx<Key>::get(m_sequence, key, pMemory)) { 150 m_type = NodeType::Sequence; 151 return *pNode; 152 } 153 154 convert_to_map(pMemory); 155 break; 156 case NodeType::Scalar: 157 throw BadSubscript(m_mark, key); 158 } 159 160 auto it = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) { 161 return m.first->equals(key, pMemory); 162 }); 163 164 if (it != m_map.end()) { 165 return *it->second; 166 } 167 168 node& k = convert_to_node(key, pMemory); 169 node& v = pMemory->create_node(); 170 insert_map_pair(k, v); 171 return v; 172 } 173 174 template <typename Key> 175 inline bool node_data::remove(const Key& key, shared_memory_holder pMemory) { 176 if (m_type == NodeType::Sequence) { 177 return remove_idx<Key>::remove(m_sequence, key, m_seqSize); 178 } 179 180 if (m_type == NodeType::Map) { 181 kv_pairs::iterator it = m_undefinedPairs.begin(); 182 while (it != m_undefinedPairs.end()) { 183 kv_pairs::iterator jt = std::next(it); 184 if (it->first->equals(key, pMemory)) { 185 m_undefinedPairs.erase(it); 186 } 187 it = jt; 188 } 189 190 auto iter = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) { 191 return m.first->equals(key, pMemory); 192 }); 193 194 if (iter != m_map.end()) { 195 m_map.erase(iter); 196 return true; 197 } 198 } 199 200 return false; 201 } 202 203 // map 204 template <typename Key, typename Value> 205 inline void node_data::force_insert(const Key& key, const Value& value, 206 shared_memory_holder pMemory) { 207 switch (m_type) { 208 case NodeType::Map: 209 break; 210 case NodeType::Undefined: 211 case NodeType::Null: 212 case NodeType::Sequence: 213 convert_to_map(pMemory); 214 break; 215 case NodeType::Scalar: 216 throw BadInsert(); 217 } 218 219 node& k = convert_to_node(key, pMemory); 220 node& v = convert_to_node(value, pMemory); 221 insert_map_pair(k, v); 222 } 223 224 template <typename T> 225 inline node& node_data::convert_to_node(const T& rhs, 226 shared_memory_holder pMemory) { 227 Node value = convert<T>::encode(rhs); 228 value.EnsureNodeExists(); 229 pMemory->merge(*value.m_pMemory); 230 return *value.m_pNode; 231 } 232 } 233 } 234 235 #endif // NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 236