nodebuilder.cpp 2.07 KB
Newer Older
1
2
3
4
5
6
7
8
#include "nodebuilder.h"
#include "mark.h"
#include "node.h"
#include "nodeproperties.h"
#include <cassert>

namespace YAML
{
9
	NodeBuilder::NodeBuilder(Node& root): m_root(root), m_initializedRoot(false)
10
11
12
13
	{
		m_root.Clear();
	}
	
14
	NodeBuilder::NodeBuilder(const NodeBuilder& o): m_root(o.m_root), m_initializedRoot(o.m_initializedRoot)
15
16
	{
	}
17
18
	
	NodeBuilder::~NodeBuilder()
19
20
21
	{
	}

22
	Node *NodeBuilder::NewNull(const std::string& tag, Node *pParent)
23
	{
24
25
26
27
		(void)pParent;
		Node *pNode = NewNode();
		pNode->InitNull(tag);
		return pNode;
28
29
	}

30
	Node *NodeBuilder::AnchorReference(const Mark& mark, Node *pNode)
31
	{
32
33
34
		Node *pAlias = NewNode();
		pAlias->InitAlias(mark, *pNode);
		return pAlias;
35
36
	}

37
	Node *NodeBuilder::NewScalar(const Mark& mark, const std::string& tag, Node *pParent, const std::string& value)
38
	{
39
40
41
42
43
		(void)pParent;
		Node *pNode = NewNode();
		pNode->Init(CT_SCALAR, mark, tag);
		pNode->SetData(value);
		return pNode;
44
45
	}

46
	NodeBuilder::Sequence *NodeBuilder::NewSequence(const Mark& mark, const std::string& tag, Node *pParent)
47
	{
48
49
50
51
		(void)pParent;
		Node *pNode = NewNode();
		pNode->Init(CT_SEQUENCE, mark, tag);
		return pNode;
52
53
	}

54
	void NodeBuilder::AppendToSequence(Sequence *pSequence, Node *pNode)
55
	{
56
57
58
		std::auto_ptr<Node> apNode(m_unlinked.pop(pNode));
		assert(apNode.get());
		pSequence->Append(apNode);
59
60
	}

61
	NodeBuilder::Map *NodeBuilder::NewMap(const Mark& mark, const std::string& tag, Node* pParent)
62
	{
63
64
65
66
		(void)pParent;
		Node *pNode = NewNode();
		pNode->Init(CT_MAP, mark, tag);
		return pNode;
67
68
	}

69
	void NodeBuilder::AssignInMap(Map *pMap, Node *pKeyNode, Node *pValueNode)
70
	{
71
72
73
74
		std::auto_ptr<Node> apKeyNode(m_unlinked.pop(pKeyNode));
		std::auto_ptr<Node> apValueNode(m_unlinked.pop(pValueNode));
		assert(apKeyNode.get() && apValueNode.get());
		pMap->Insert(apKeyNode, apValueNode);
75
76
	}
	
77
	Node* NodeBuilder::NewNode()
78
79
80
	{
		if(!m_initializedRoot) {
			m_initializedRoot = true;
81
			return &m_root;
82
83
84
		}
		
		std::auto_ptr<Node> pNode(new Node);
85
86
87
88
		Node* pResult = pNode.get();
		// Save the pointer in a collection that will free it on exception
		m_unlinked.push(pNode);
		return pResult;
89
90
	}
}