nodebuilder.cpp 2.7 KB
Newer Older
1
#include "nodebuilder.h"
2
#include "yaml-cpp/mark.h"
3
4
#include "yaml-cpp/node/node.h"
#include "yaml-cpp/node/impl.h"
5
6
7
8
#include <cassert>

namespace YAML
{
9
	NodeBuilder::NodeBuilder(): m_pMemory(new detail::memory_holder), m_pRoot(0), m_mapDepth(0)
10
11
12
13
	{
		m_anchors.push_back(0); // since the anchors start at 1
	}
	
14
	NodeBuilder::~NodeBuilder()
15
16
17
	{
	}
	
18
	Node NodeBuilder::Root()
19
20
	{
		if(!m_pRoot)
21
			return Node();
22
		
23
		return Node(*m_pRoot, m_pMemory);
24
25
	}

26
	void NodeBuilder::OnDocumentStart(const Mark&)
27
28
29
	{
	}
	
30
	void NodeBuilder::OnDocumentEnd()
31
32
33
	{
	}
	
34
	void NodeBuilder::OnNull(const Mark& mark, anchor_t anchor)
35
36
37
38
39
40
	{
		detail::node& node = Push(anchor);
		node.set_null();
		Pop();
	}
	
41
	void NodeBuilder::OnAlias(const Mark& /*mark*/, anchor_t anchor)
42
43
	{
		detail::node& node = *m_anchors[anchor];
44
		Push(node);
45
46
47
		Pop();
	}
	
48
	void NodeBuilder::OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value)
49
50
51
52
53
54
	{
		detail::node& node = Push(anchor);
		node.set_scalar(value);
		Pop();
	}
	
55
	void NodeBuilder::OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor)
56
57
	{
		detail::node& node = Push(anchor);
58
		node.set_type(NodeType::Sequence);
59
60
	}
	
61
	void NodeBuilder::OnSequenceEnd()
62
63
64
65
	{
		Pop();
	}
	
66
	void NodeBuilder::OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor)
67
68
	{
		detail::node& node = Push(anchor);
69
		node.set_type(NodeType::Map);
70
71
72
		m_mapDepth++;
	}
	
73
	void NodeBuilder::OnMapEnd()
74
75
76
77
78
79
	{
		assert(m_mapDepth > 0);
		m_mapDepth--;
		Pop();
	}

80
	detail::node& NodeBuilder::Push(anchor_t anchor)
81
82
83
	{
		detail::node& node = m_pMemory->create_node();
		RegisterAnchor(anchor, node);
84
85
86
87
88
89
90
		Push(node);
		return node;
	}
	
	void NodeBuilder::Push(detail::node& node)
	{
		const bool needsKey = (!m_stack.empty() && m_stack.back()->type() == NodeType::Map && m_keys.size() < m_mapDepth);
91
		
92
		m_stack.push_back(&node);
93
		if(needsKey)
94
			m_keys.push_back(PushedKey(&node, false));
95
96
	}
	
97
	void NodeBuilder::Pop()
98
99
100
101
102
103
104
105
106
107
108
109
110
	{
		assert(!m_stack.empty());
		if(m_stack.size() == 1) {
			m_pRoot = m_stack[0];
			m_stack.pop_back();
			return;
		}
		
		detail::node& node = *m_stack.back();
		m_stack.pop_back();

		detail::node& collection = *m_stack.back();
		
111
		if(collection.type() == NodeType::Sequence) {
112
			collection.append(node, m_pMemory);
113
		} else if(collection.type() == NodeType::Map) {
114
115
			assert(!m_keys.empty());
			PushedKey& key = m_keys.back();
116
117
			if(key.second) {
				collection.insert(*key.first, node, m_pMemory);
118
				m_keys.pop_back();
119
120
			} else {
				key.second = true;
121
122
123
124
125
126
127
			}
		} else {
			assert(false);
			m_stack.clear();
		}
	}

128
	void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node)
129
130
131
132
133
134
135
	{
		if(anchor) {
			assert(anchor == m_anchors.size());
			m_anchors.push_back(&node);
		}
	}
}