/*
* Copyright (c) 2010-2016. Axon Framework
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.axonframework.mongo.serialization;
import com.mongodb.BasicDBList;
import com.mongodb.BasicDBObject;
import com.mongodb.DBObject;
import org.axonframework.common.Assert;
import java.util.*;
import java.util.stream.Collectors;
/**
* Represents a node in a BSON structure. This class provides for an XML like abstraction around BSON for use by the
* XStream Serializer.
*
* @author Allard Buijze
* @since 2.0
*/
public class BSONNode {
private static final String ATTRIBUTE_PREFIX = "attr_";
private static final String VALUE_KEY = "_value";
private final List<BSONNode> childNodes = new ArrayList<>();
private String value;
private final String encodedName;
/**
* Creates a node with given "code" name. Generally, this constructor is used for the root node. For child nodes,
* see the convenience method {@link #addChildNode(String)}.
* <p/>
* Note that the given {@code name} is encoded in a BSON compatible way. That means that periods (".") are
* replaced by forward slashes "/", and any slashes are prefixes with additional slash. For example, the String
* "some.period/slash" would become "some/period//slash". This is only imporant when querying BSON structures
* directly.
*
* @param name The name of this node
*/
public BSONNode(String name) {
this.encodedName = encode(name);
}
/**
* Constructrs a BSONNode structure from the given DBObject structure. The node returned is the root node.
*
* @param node The root DBObject node containing the BSON Structure
* @return The BSONNode representing the root of the BSON structure
*/
public static BSONNode fromDBObject(DBObject node) {
if (node.keySet().size() != 1) {
throw new IllegalArgumentException("Given node should have exactly one attribute");
}
String rootName = node.keySet().iterator().next();
BSONNode rootNode = new BSONNode(decode(rootName));
Object rootContents = node.get(rootName);
if (rootContents instanceof List) {
((List<?>) rootContents).stream().filter(childElement -> childElement instanceof DBObject)
.forEach(childElement -> {
DBObject dbChild = (DBObject) childElement;
if (dbChild.containsField(VALUE_KEY)) {
rootNode.setValue((String) dbChild.get(VALUE_KEY));
} else {
rootNode.addChildNode(fromDBObject(dbChild));
}
});
} else if (rootContents instanceof DBObject) {
rootNode.addChildNode(fromDBObject((DBObject) rootContents));
} else if (rootContents instanceof String) {
rootNode.setValue((String) rootContents);
} else {
throw new IllegalArgumentException(
"Node in " + rootName + " contains child " + rootContents + " which cannot be parsed");
}
return rootNode;
}
private void addChildNode(BSONNode bsonNode) {
this.childNodes.add(bsonNode);
}
/**
* Returns the current BSON structure as DBObject.
*
* @return the current BSON structure as DBObject
*/
public DBObject asDBObject() {
if (childNodes.isEmpty() && value != null) {
// only a value
return new BasicDBObject(encodedName, value);
} else if (childNodes.size() == 1 && value == null) {
return new BasicDBObject(encodedName, childNodes.get(0).asDBObject());
} else {
BasicDBList subNodes = new BasicDBList();
BasicDBObject thisNode = new BasicDBObject(encodedName, subNodes);
if (value != null) {
subNodes.add(new BasicDBObject(VALUE_KEY, value));
}
subNodes.addAll(childNodes.stream().map(BSONNode::asDBObject).collect(Collectors.toList()));
return thisNode;
}
}
/**
* Sets the value of this node. Note that a node can contain either a value, or child nodes
*
* @param value The value to set for this node
*/
public void setValue(String value) {
Assert.isFalse(children().hasNext(),
() -> "A child node was already present. " + "A node cannot contain a value as well as child nodes.");
this.value = value;
}
/**
* Sets an attribute to this node. Since JSON (and BSON) do not have the notion of attributes, these are modelled
* as child nodes with their name prefixed with "attr_". Attributes are represented as nodes that <em>always</em>
* exclusively contain a value.
*
* @param attributeName The name of the attribute to add
* @param attributeValue The value of the attribute
*/
public void setAttribute(String attributeName, String attributeValue) {
addChild(ATTRIBUTE_PREFIX + attributeName, attributeValue);
}
/**
* Adds a child node to the current node. Note that the name of a child node must not be {@code null} and may
* not start with "attr_", in order to differentiate between child nodes and attributes.
*
* @param name The name of the child node
* @return A BSONNode representing the newly created child node.
*/
public BSONNode addChildNode(String name) {
Assert.isTrue(value == null,
() -> "A value was already present." + "A node cannot contain a value as well as child nodes");
Assert.notNull(name, () -> "Node name must not be null");
Assert.isFalse(name.startsWith(ATTRIBUTE_PREFIX), () -> "Node names may not start with '" + ATTRIBUTE_PREFIX + "'");
return addChild(name, null);
}
private BSONNode addChild(String name, String nodeValue) {
BSONNode childNode = new BSONNode(name);
childNode.setValue(nodeValue);
this.childNodes.add(childNode);
return childNode;
}
/**
* Returns an iterator providing access to the child nodes of the current node. Changes to the node structure made
* after this iterator is returned may not be reflected in that iterator.
*
* @return an iterator providing access to the child nodes of the current node
*/
public Iterator<BSONNode> children() {
List<BSONNode> children = childNodes.stream().filter(child -> !child.encodedName.startsWith(ATTRIBUTE_PREFIX))
.collect(Collectors.toList());
return children.iterator();
}
/**
* Returns a map containing the attributes of the current node. Changes to the node's attributes made
* after this iterator is returned may not be reflected in that iterator.
*
* @return a Map containing the attributes of the current node
*/
public Map<String, String> attributes() {
Map<String, String> attrs = new HashMap<>();
childNodes.stream()
.filter(child -> !VALUE_KEY.equals(child.encodedName) && child.encodedName.startsWith(ATTRIBUTE_PREFIX))
.forEach(child -> attrs.put(child.encodedName, child.value));
return attrs;
}
/**
* Returns the value of the attribute with given {@code name}.
*
* @param name The name of the attribute to get the value for
* @return the value of the attribute, or {@code null} if the attribute was not found
*/
public String getAttribute(String name) {
String attr = ATTRIBUTE_PREFIX + name;
return getChildValue(attr);
}
private String getChildValue(String name) {
for (BSONNode node : childNodes) {
if (name.equals(node.encodedName)) {
return node.value;
}
}
return null;
}
/**
* Returns the value of the current node
*
* @return the value of the current node, or {@code null} if this node has no value.
*/
public String getValue() {
return value;
}
/**
* Returns the name of the current node
*
* @return the name of the current node
*/
public String getName() {
return decode(encodedName);
}
private static String encode(String name) {
return name.replaceAll("\\/", "\\/\\/").replaceAll("\\.", "/");
}
private static String decode(String name) {
return name.replaceAll("\\/([^/]])?", ".$1").replaceAll("\\/\\/", "/");
}
}