peisongxiao/yaml-cpp
1
0
Fork 0
mirror of https://github.com/jbeder/yaml-cpp.git synced 2025-09-09 12:41:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Started specialization for operator[] for integers

Browse Source
This commit is contained in:
beder
2011-09-11 21:32:47 -05:00
parent d8955fc52c
commit e8210b476c
3 changed files with 81 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
include/yaml-cpp/node/detail/impl.h
View File

@@ -13,12 +13,42 @@ 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))
@@ -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) {

2
include/yaml-cpp/node/detail/node_data.h
View File

@@ -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>

53
src/node/detail/node_data.cpp
View File

@@ -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);