Method: getTreeRoot()

1: /**
2: * Copyright (C) 2022 Czech Technical University in Prague
3: * <p>
4: * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public
5: * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later
6: * version.
7: * <p>
8: * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
9: * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
10: * details. You should have received a copy of the GNU General Public License along with this program. If not, see
11: * <http://www.gnu.org/licenses/>.
12: */
13: package cz.cvut.kbss.jsonld.serialization;
14:
15: import cz.cvut.kbss.jsonld.serialization.context.JsonLdContextFactory;
16: import cz.cvut.kbss.jsonld.serialization.model.CollectionNode;
17: import cz.cvut.kbss.jsonld.serialization.model.CompositeNode;
18: import cz.cvut.kbss.jsonld.serialization.model.JsonNode;
19: import cz.cvut.kbss.jsonld.serialization.model.ObjectNode;
20: import cz.cvut.kbss.jsonld.serialization.serializer.ValueSerializer;
21: import cz.cvut.kbss.jsonld.serialization.serializer.ValueSerializers;
22: import cz.cvut.kbss.jsonld.serialization.traversal.InstanceVisitor;
23: import cz.cvut.kbss.jsonld.serialization.traversal.SerializationContext;
24:
25: import java.util.Collection;
26: import java.util.Set;
27: import java.util.Stack;
28:
29: /**
30: * Builds an abstract representation of a JSON-LD tree, which is a result of object graph traversal by {@link
31: * cz.cvut.kbss.jsonld.serialization.traversal.ObjectGraphTraverser}.
32: */
33: public class JsonLdTreeBuilder implements InstanceVisitor {
34:
35: private final Stack<CompositeNode<?>> nodeStack = new Stack<>();
36: private CompositeNode<?> currentNode;
37:
38: private final ValueSerializers serializers;
39: private final JsonLdContextFactory jsonLdContextFactory;
40:
41: public JsonLdTreeBuilder(ValueSerializers serializers, JsonLdContextFactory jsonLdContextFactory) {
42: this.serializers = serializers;
43: this.jsonLdContextFactory = jsonLdContextFactory;
44: }
45:
46: @Override
47: public boolean visitObject(SerializationContext<?> ctx) {
48: if (serializers.hasCustomSerializer(ctx.getValue().getClass())) {
49: final ValueSerializer serializer = serializers.getSerializer(ctx).get();
50: final JsonNode node = serializer.serialize(ctx.getValue(), ctx);
51: if (node != null) {
52: if (currentNode != null) {
53: currentNode.addItem(node);
54: } else {
55: assert node instanceof CompositeNode;
56: currentNode = (CompositeNode<?>) node;
57: }
58: }
59: return false;
60: }
61: return true;
62: }
63:
64: @Override
65: public void openObject(SerializationContext<?> ctx) {
66: final ObjectNode newCurrent = ctx.getTerm() != null ? JsonNodeFactory.createObjectNode(ctx.getTerm()) :
67: JsonNodeFactory.createObjectNode();
68: openNewNode(newCurrent);
69: // Prepare to create new JSON-LD context when an object is open
70: ctx.setJsonLdContext(jsonLdContextFactory.createJsonLdContext(ctx.getJsonLdContext()));
71: }
72:
73: private void openNewNode(CompositeNode<?> newNode) {
74: if (currentNode != null) {
75: if (currentNode.isOpen()) {
76: nodeStack.push(currentNode);
77: }
78: currentNode.addItem(newNode);
79: }
80: this.currentNode = newNode;
81: }
82:
83: @Override
84: public void closeObject(SerializationContext<?> ctx) {
85: if (!ctx.isCurrentEmpty()) {
86: currentNode.prependItem(ctx.getContextNode());
87: }
88: closeCurrentNode();
89: }
90:
91: private void closeCurrentNode() {
92: currentNode.close();
93: if (!nodeStack.empty()) {
94: this.currentNode = nodeStack.pop();
95: }
96: }
97:
98: @Override
99: public void visitIdentifier(SerializationContext<String> idCtx) {
100: assert currentNode.isOpen();
101: currentNode.addItem(serializers.getIdentifierSerializer().serialize(idCtx.getValue(), idCtx));
102: }
103:
104: @Override
105: public void visitTypes(SerializationContext<Set<String>> typesCtx) {
106: currentNode.addItem(serializers.getTypesSerializer().serialize(typesCtx.getValue(), typesCtx));
107: }
108:
109: @Override
110: public void visitAttribute(SerializationContext<?> ctx) {
111: if (ctx.getValue() != null) {
112: assert currentNode != null;
113: final ValueSerializer serializer = serializers.getOrDefault(ctx);
114: final JsonNode node = serializer.serialize(ctx.getValue(), ctx);
115: if (node != null) {
116: currentNode.addItem(node);
117: }
118: }
119: }
120:
121: @Override
122: public void openCollection(SerializationContext<? extends Collection<?>> ctx) {
123: final CollectionNode<?> newCurrent =
124: ctx.getTerm() != null ? JsonNodeFactory.createCollectionNode(ctx.getTerm(),
125: ctx.getValue()) :
126: JsonNodeFactory.createCollectionNode(ctx.getValue());
127: openNewNode(newCurrent);
128: }
129:
130: @Override
131: public void closeCollection(SerializationContext<?> ctx) {
132: assert currentNode instanceof CollectionNode;
133: closeCurrentNode();
134: }
135:
136: public CompositeNode<?> getTreeRoot() {
137: return currentNode;
138: }
139: }