1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
// a sketch of what the new API might look like
#include "yaml-cpp/yaml.h"
#include <iostream>
int main() {
{
// test.yaml
// - foo
// - primes: [2, 3, 5, 7, 11]
// odds: [1, 3, 5, 7, 9, 11]
// - [x, y]
// move-like semantics
YAML::Value root = YAML::Parse("test.yaml");
std::cout << root[0].as<std::string>(); // "foo"
std::cout << str(root[0]); // "foo", shorthand?
std::cout << root[1]["primes"][3].as<int>(); // "7"
std::cout << root[1]["odds"][6].as<int>(); // throws?
root[2].push_back(5);
root[3] = "Hello, World";
root[0].reset();
root[0]["key"] = "value";
std::cout << root;
// # not sure about formatting
// - {key: value}
// - primes: [2, 3, 5, 7, 11]
// odds: [1, 3, 5, 7, 9, 11]
// - [x, y, 5]
// - Hello, World
}
{
// for all copy-like commands, think of python's "name/value" semantics
YAML::Value root = "Hello"; // Hello
root = YAML::Sequence(); // []
root[0] = 0; // [0]
root[2] = "two"; // [0, ~, two] # forces root[1] to be initialized to null
YAML::Value other = root; // both point to the same thing
other[0] = 5; // now root[0] is 0 also
other.push_back(root); // &1 [5, ~, two, *1]
other[3][0] = 0; // &1 [0, ~, two, *1] # since it's a true alias
other.push_back(Copy(root)); // &1 [0, ~, two, *1, &2 [0, ~, two, *2]]
other[4][0] = 5; // &1 [0, ~, two, *1, &2 [5, ~, two, *2]] # they're
// really different
}
{
YAML::Value node; // ~
node[0] = 1; // [1] # auto-construct a sequence
node["key"] = 5; // {0: 1, key: 5} # auto-turn it into a map
node.push_back(10); // error, can't turn a map into a sequence
node.erase("key"); // {0: 1} # still a map, even if we remove the key that
// caused the problem
node = "Hello"; // Hello # assignment overwrites everything, so it's now
// just a plain scalar
}
{
YAML::Value map; // ~
map[3] = 1; // {3: 1} # auto-constructs a map, *not* a sequence
YAML::Value seq; // ~
seq = YAML::Sequence(); // []
seq[3] = 1; // [~, ~, ~, 1]
}
{
YAML::Value node; // ~
node[0] = node; // &1 [*1] # fun stuff
}
{
YAML::Value node;
YAML::Value subnode =
node["key"]; // 'subnode' is not instantiated ('node' is still null)
subnode = "value"; // {key: value} # now it is
YAML::Value subnode2 = node["key2"];
node["key3"] = subnode2; // subnode2 is still not instantiated, but
// node["key3"] is "pseudo" aliased to it
subnode2 = "monkey"; // {key: value, key2: &1 monkey, key3: *1} # bam! it
// instantiates both
}
{
YAML::Value seq = YAML::Sequence();
seq[0] = "zero"; // [zero]
seq[1] = seq[0]; // [&1 zero, *1]
seq[0] = seq[1]; // [&1 zero, *1] # no-op (they both alias the same thing,
// so setting them equal is nothing)
Is(seq[0], seq[1]); // true
seq[1] = "one"; // [&1 one, *1]
UnAlias(seq[1]); // [one, one]
Is(seq[0], seq[1]); // false
}
{
YAML::Value root;
root.push_back("zero");
root.push_back("one");
root.push_back("two");
YAML::Value two = root[2];
root = "scalar"; // 'two' is still "two", even though 'root' is "scalar"
// (the sequence effectively no longer exists)
// Note: in all likelihood, the memory for nodes "zero" and "one" is still
// allocated. How can it go away? Weak pointers?
}
{
YAML::Value root; // ~
root[0] = root; // &1 [*1]
root[0] = 5; // [5]
}
{
YAML::Value root;
YAML::Value key;
key["key"] = "value";
root[key] = key; // &1 {key: value}: *1
}
{
YAML::Value root;
root[0] = "hi";
root[1][0] = "bye";
root[1][1] = root; // &1 [hi, [bye, *1]] # root
YAML::Value sub = root[1]; // &1 [bye, [hi, *1]] # sub
root = "gone"; // [bye, gone] # sub
}
return 0;
}
|
