1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.yaml.snakeyaml;
18
19 import java.io.IOException;
20 import java.util.List;
21 import java.util.Map;
22 import java.util.TreeMap;
23
24 import junit.framework.TestCase;
25
26 import org.yaml.snakeyaml.constructor.AbstractConstruct;
27 import org.yaml.snakeyaml.constructor.Constructor;
28 import org.yaml.snakeyaml.nodes.MappingNode;
29 import org.yaml.snakeyaml.nodes.Node;
30 import org.yaml.snakeyaml.nodes.SequenceNode;
31 import org.yaml.snakeyaml.nodes.Tag;
32 import org.yaml.snakeyaml.representer.Represent;
33 import org.yaml.snakeyaml.representer.Representer;
34
35
36
37
38
39
40
41 public class Example2_24Test extends TestCase {
42 class MyConstructor extends Constructor {
43 public MyConstructor() {
44 this.yamlConstructors.put(new Tag("tag:clarkevans.com,2002:shape"),
45 new ConstructShape());
46 this.yamlConstructors.put(new Tag("tag:clarkevans.com,2002:circle"),
47 new ConstructCircle());
48 this.yamlConstructors.put(new Tag("tag:clarkevans.com,2002:line"), new ConstructLine());
49 this.yamlConstructors.put(new Tag("tag:clarkevans.com,2002:label"),
50 new ConstructLabel());
51 }
52
53 private class ConstructShape extends AbstractConstruct {
54 @SuppressWarnings("unchecked")
55 public Object construct(Node node) {
56 SequenceNode snode = (SequenceNode) node;
57 List<Entity> values = (List<Entity>) constructSequence(snode);
58 Shape shape = new Shape(values);
59 return shape;
60 }
61 }
62
63 private class ConstructCircle extends AbstractConstruct {
64 @SuppressWarnings("unchecked")
65 public Object construct(Node node) {
66 MappingNode mnode = (MappingNode) node;
67 Map<Object, Object> values = constructMapping(mnode);
68 Circle circle = new Circle((Map<String, Integer>) values.get("center"),
69 (Integer) values.get("radius"));
70 return circle;
71 }
72 }
73
74 private class ConstructLine extends AbstractConstruct {
75 @SuppressWarnings("unchecked")
76 public Object construct(Node node) {
77 MappingNode mnode = (MappingNode) node;
78 Map<Object, Object> values = constructMapping(mnode);
79 Line line = new Line((Map<String, Integer>) values.get("start"),
80 (Map<String, Integer>) values.get("finish"));
81 return line;
82 }
83 }
84
85 private class ConstructLabel extends AbstractConstruct {
86 @SuppressWarnings("unchecked")
87 public Object construct(Node node) {
88 MappingNode mnode = (MappingNode) node;
89 Map<Object, Object> values = constructMapping(mnode);
90 Label label = new Label((Map<String, Integer>) values.get("start"),
91 (Integer) values.get("color"), (String) values.get("text"));
92 return label;
93 }
94 }
95 }
96
97 class MyRepresenter extends Representer {
98 public MyRepresenter() {
99 this.representers.put(Shape.class, new RepresentShape());
100 this.representers.put(Circle.class, new RepresentCircle());
101 this.representers.put(Line.class, new RepresentLine());
102 this.representers.put(Label.class, new RepresentLabel());
103 this.representers.put(HexInteger.class, new RepresentHex());
104 }
105
106 private class RepresentShape implements Represent {
107 public Node representData(Object data) {
108 Shape shape = (Shape) data;
109 List<Entity> value = shape.getEntities();
110 return representSequence(new Tag("!shape"), value, Boolean.FALSE);
111 }
112 }
113
114 private class RepresentCircle implements Represent {
115 public Node representData(Object data) {
116 Circle circle = (Circle) data;
117 Map<String, Object> map = new TreeMap<String, Object>();
118 map.put("center", circle.getCenter());
119 map.put("radius", circle.getRadius());
120 return representMapping(new Tag("!circle"), map, Boolean.FALSE);
121 }
122 }
123
124 private class RepresentLine implements Represent {
125 public Node representData(Object data) {
126 Line line = (Line) data;
127 Map<String, Object> map = new TreeMap<String, Object>();
128 map.put("start", line.getStart());
129 map.put("finish", line.getFinish());
130 return representMapping(new Tag("!line"), map, Boolean.FALSE);
131 }
132 }
133
134 private class RepresentLabel implements Represent {
135 public Node representData(Object data) {
136 Label label = (Label) data;
137 Map<String, Object> map = new TreeMap<String, Object>();
138 map.put("start", label.getStart());
139 map.put("color", new HexInteger(label.getColor()));
140 map.put("text", label.getText());
141 return representMapping(new Tag("!label"), map, Boolean.FALSE);
142 }
143 }
144
145 private class RepresentHex implements Represent {
146 public Node representData(Object data) {
147 HexInteger hex = (HexInteger) data;
148 return representScalar(Tag.INT, "0x"
149 + Integer.toHexString(hex.getColor()).toUpperCase(), null);
150 }
151 }
152 }
153
154 private class HexInteger {
155 private Integer color;
156
157 public HexInteger(Integer color) {
158 this.color = color;
159 }
160
161 public Integer getColor() {
162 return color;
163 }
164 }
165
166 private class Shape {
167 private List<Entity> entities;
168
169 public List<Entity> getEntities() {
170 return entities;
171 }
172
173 public Shape(List<Entity> entities) {
174 this.entities = entities;
175 }
176 }
177
178 private class Entity {
179 }
180
181 private class Circle extends Entity {
182 private Map<String, Integer> center;
183 private Integer radius;
184
185 public Circle(Map<String, Integer> center, Integer radius) {
186 this.center = center;
187 this.radius = radius;
188 }
189
190 public Map<String, Integer> getCenter() {
191 return center;
192 }
193
194 public Integer getRadius() {
195 return radius;
196 }
197 }
198
199 private class Line extends Entity {
200 private Map<String, Integer> start;
201 private Map<String, Integer> finish;
202
203 public Line(Map<String, Integer> start, Map<String, Integer> finish) {
204 this.start = start;
205 this.finish = finish;
206 }
207
208 public Map<String, Integer> getStart() {
209 return start;
210 }
211
212 public Map<String, Integer> getFinish() {
213 return finish;
214 }
215 }
216
217 private class Label extends Entity {
218 private Map<String, Integer> start;
219 private Integer color;
220 private String text;
221
222 public Label(Map<String, Integer> start, Integer color, String text) {
223 this.start = start;
224 this.color = color;
225 this.text = text;
226 }
227
228 public Map<String, Integer> getStart() {
229 return start;
230 }
231
232 public Integer getColor() {
233 return color;
234 }
235
236 public String getText() {
237 return text;
238 }
239 }
240
241 public void testExample_2_24() throws IOException {
242 Yaml yaml = new Yaml(new MyConstructor());
243 Shape shape = (Shape) yaml.load(Util.getLocalResource("specification/example2_24.yaml"));
244 assertNotNull(shape);
245 yaml = new Yaml(new MyRepresenter());
246 String output = yaml.dump(shape);
247 String etalon = Util.getLocalResource("specification/example2_24_dumped.yaml");
248 assertEquals(etalon, output);
249 }
250 }