*/
package org.opendaylight.yangtools.sal.binding.generator.impl
+import com.google.common.collect.ImmutableList
+import java.util.ArrayList
+import java.util.Collections
+import java.util.HashMap
+import java.util.List
+import java.util.Map
+import java.util.WeakHashMap
+import java.util.concurrent.ConcurrentHashMap
+import org.opendaylight.yangtools.yang.binding.Augmentation
+import org.opendaylight.yangtools.yang.binding.DataObject
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier
-import org.opendaylight.yangtools.yang.data.impl.codec.CodecRegistry
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem
-import org.opendaylight.yangtools.yang.common.QName
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.Item
-import java.util.Map
-import java.util.WeakHashMap
+import org.opendaylight.yangtools.yang.binding.util.BindingReflections
+import org.opendaylight.yangtools.yang.common.QName
+import org.opendaylight.yangtools.yang.data.api.CompositeNode
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates
-import java.util.ArrayList
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument
+import org.opendaylight.yangtools.yang.data.api.Node
+import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl
+import org.opendaylight.yangtools.yang.data.impl.SimpleNodeTOImpl
+import org.opendaylight.yangtools.yang.data.impl.codec.CodecRegistry
+import org.opendaylight.yangtools.yang.data.impl.codec.IdentifierCodec
import org.opendaylight.yangtools.yang.data.impl.codec.InstanceIdentifierCodec
import org.opendaylight.yangtools.yang.data.impl.codec.ValueWithQName
-import java.util.HashMap
import org.slf4j.LoggerFactory
-import java.util.List
-import org.opendaylight.yangtools.yang.binding.DataObject
-import org.opendaylight.yangtools.yang.data.impl.codec.IdentifierCodec
-import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl
-import org.opendaylight.yangtools.yang.data.api.Node
-import org.opendaylight.yangtools.yang.data.impl.SimpleNodeTOImpl
-import org.opendaylight.yangtools.yang.data.api.CompositeNode
-import org.opendaylight.yangtools.yang.binding.Augmentable
-import com.google.common.collect.ImmutableList
-import org.opendaylight.yangtools.yang.binding.Augmentation
-import java.util.concurrent.ConcurrentHashMap
-import org.opendaylight.yangtools.yang.binding.util.BindingReflections
-import java.util.Collections
class InstanceIdentifierCodecImpl implements InstanceIdentifierCodec {
var Class<?> baType = null
val biArgs = input.path
val scannedPath = new ArrayList<QName>(biArgs.size);
- val baArgs = new ArrayList<org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument>(biArgs.size)
+ val baArgs = new ArrayList<InstanceIdentifier.PathArgument>(biArgs.size)
for(biArg : biArgs) {
scannedPath.add(biArg.nodeType);
val baArg = deserializePathArgument(biArg,scannedPath)
return ret;
}
- private def dispatch org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument deserializePathArgument(NodeIdentifier argument,List<QName> processedPath) {
+ private def dispatch InstanceIdentifier.PathArgument deserializePathArgument(NodeIdentifier argument,List<QName> processedPath) {
val Class cls = codecRegistry.getClassForPath(processedPath);
return new Item(cls);
}
- private def dispatch org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument deserializePathArgument(NodeIdentifierWithPredicates argument,List<QName> processedPath) {
+ private def dispatch InstanceIdentifier.PathArgument deserializePathArgument(NodeIdentifierWithPredicates argument,List<QName> processedPath) {
val Class type = codecRegistry.getClassForPath(processedPath);
val IdentifierCodec codec = codecRegistry.getIdentifierCodecForIdentifiable(type);
val value = codec.deserialize(argument.toCompositeNode())?.value;
return new CompositeNodeTOImpl(predicates.nodeType,null,values);
}
- override serialize(InstanceIdentifier input) {
+ override serialize(InstanceIdentifier<?> input) {
var Class<?> previousAugmentation = null
- val pathArgs = input.path as List<org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument>
+ val pathArgs = input.path as List<InstanceIdentifier.PathArgument>
var QName previousQName = null;
val components = new ArrayList<PathArgument>(pathArgs.size);
val qnamePath = new ArrayList<QName>(pathArgs.size);
previousAugmentation = null;
} else {
- previousQName = codecRegistry.getQNameForAugmentation(baArg.type as Class);
+ previousQName = codecRegistry.getQNameForAugmentation(baArg.type as Class<?>);
previousAugmentation = baArg.type;
}
}
classToPreviousAugment.get(class1).put(list,augmentation);
}
- private def dispatch PathArgument serializePathArgument(Item argument, QName previousQname) {
+ private def dispatch PathArgument serializePathArgument(Item<?> argument, QName previousQname) {
val type = argument.type;
val qname = BindingReflections.findQName(type);
if(previousQname == null || (BindingReflections.isAugmentationChild(argument.type))) {
<parent>
<groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yangtools</artifactId>
+ <artifactId>common-parent</artifactId>
<version>0.6.2-SNAPSHOT</version>
</parent>
<packaging>bundle</packaging>
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.concepts;
+
+/**
+ * An extension of the {@link Builder} concept which allows an implementation
+ * of this interface to be used in collections instead of the product. Given
+ * the mutable nature of Builders, this has to be done very carefully.
+ *
+ * @param <P> Product type
+ */
+public interface ProductAwareBuilder<P> extends Builder<P> {
+ /**
+ * Return the hash code of the product. This has to be equivalent
+ * of calling {@link #toInstance()}.{@link #hashCode()}.
+ *
+ * @return the hash code of the product.
+ */
+ int productHashCode();
+
+ /**
+ * Check whether an instance of the product that would be created
+ * by the builder is equal to an existing instance. This has to
+ * be equivalent of calling {@link #toInstance()}.{@link #equals(Object)}.
+ *
+ * @param product Product instance
+ * @return Return true if the product is equal to the would-be
+ * product of the builder.
+ */
+ boolean productEquals(Object product);
+}
<parent>
<groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yangtools</artifactId>
+ <artifactId>common-parent</artifactId>
<version>0.6.2-SNAPSHOT</version>
</parent>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- vi: set et smarttab sw=4 tabstop=4: -->
+<!--
+ Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ and is available at http://www.eclipse.org/legal/epl-v10.html
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+ <parent>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yangtools</artifactId>
+ <version>0.6.2-SNAPSHOT</version>
+ </parent>
+
+ <modelVersion>4.0.0</modelVersion>
+ <artifactId>common-parent</artifactId>
+ <packaging>pom</packaging>
+
+ <modules>
+ <module>concepts</module>
+ <module>mockito-configuration</module>
+ </modules>
+
+</project>
</scm>
<modules>
- <module>concepts</module>
- <module>yang</module>
<module>code-generator</module>
+ <module>common</module>
+ <module>integration-test</module>
<module>model</module>
<module>restconf</module>
- <module>integration-test</module>
- <module>mockito-configuration</module>
<module>websocket</module>
+ <module>yang</module>
<!-- module>third-party</module -->
</modules>
*/
package org.opendaylight.yangtools.restconf.client;
-import com.google.common.base.Function;
-import com.google.common.base.Optional;
-import com.sun.jersey.api.client.ClientResponse;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;
+
import org.opendaylight.yangtools.restconf.client.to.RestRpcError;
import org.opendaylight.yangtools.restconf.client.to.RestRpcResult;
import org.opendaylight.yangtools.restconf.common.ResourceUri;
import org.w3c.dom.ls.DOMImplementationLS;
import org.w3c.dom.ls.LSSerializer;
+import com.google.common.base.Function;
+import com.google.common.base.Optional;
+import com.sun.jersey.api.client.ClientResponse;
+
public class BindingToRestRpc implements InvocationHandler {
private final RestconfClientImpl client;
private final SchemaContext schcemaContext;
private final Module module;
- public BindingToRestRpc(Class proxiedInterface,BindingIndependentMappingService mappingService,RestconfClientImpl client,SchemaContext schemaContext) throws Exception {
+ public BindingToRestRpc(Class<?> proxiedInterface,BindingIndependentMappingService mappingService,RestconfClientImpl client,SchemaContext schemaContext) throws Exception {
this.mappingService = mappingService;
this.client = client;
this.schcemaContext = schemaContext;
*/
package org.opendaylight.yangtools.restconf.client;
-import com.google.common.base.Charsets;
-import com.google.common.base.Function;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.ListeningExecutorService;
-import com.google.common.util.concurrent.MoreExecutors;
-import com.sun.jersey.api.client.ClientResponse;
import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
+
import java.io.UnsupportedEncodingException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
+
import javax.ws.rs.core.MediaType;
+
import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.restconf.client.api.event.EventStreamInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import com.google.common.base.Charsets;
+import com.google.common.base.Function;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.sun.jersey.api.client.ClientResponse;
+
*/
package org.opendaylight.yangtools.yang.binding.test;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import org.junit.Test;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Test
public void constructWithPredicates() {
-
+
InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).toInstance();
-
+
assertNotNull(nodes);
assertEquals(Nodes.class, nodes.getTargetType());
-
-
- InstanceIdentifier<Node> node = InstanceIdentifier.builder(nodes).node(Node.class).toInstance();
-
+
+
+ InstanceIdentifier<Node> node = InstanceIdentifier.builder(nodes).child(Node.class).toInstance();
+
assertNotNull(node);
assertEquals(Node.class, node.getTargetType());
-
+
assertTrue(nodes.contains(node));
}
assertTrue(nodes.contains(node));
}
-
-
+
+
@Test
public void negativeContains() {
InstanceIdentifier<FooChild> fooChild = InstanceIdentifier.builder(Nodes.class).child(InstantiatedFoo.class).child(FooChild.class).build();
-
+
InstanceIdentifier<Node> nodeTen = InstanceIdentifier.builder(Nodes.class) //
.child(Node.class,new NodeKey(10)).toInstance();
InstanceIdentifier<Node> nodeOne = InstanceIdentifier.builder(Nodes.class) //
.child(Node.class,new NodeKey(1)).toInstance();
InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).toInstance();
-
+
assertFalse(fooChild.contains(nodeTen));
assertFalse(nodeTen.contains(nodes));
-
+
assertFalse(nodeOne.contains(nodes));
assertTrue(nodes.contains(nodeOne));
}
-
+
@Test
public void containsWildcarded() {
InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).toInstance();
InstanceIdentifier<NodeChild> wildcardedChildren = InstanceIdentifier.builder(Nodes.class) //
.child(Node.class) //
.child(NodeChild.class).build();
-
+
assertTrue(wildcarded.isWildcarded());
assertTrue(wildcardedChildren.isWildcarded());
-
-
+
+
InstanceIdentifier<Node> nodeTen = InstanceIdentifier.builder(Nodes.class) //
.child(Node.class,new NodeKey(10)).toInstance();
InstanceIdentifier<Node> nodeOne = InstanceIdentifier.builder(Nodes.class) //
.child(Node.class,new NodeKey(1)).toInstance();
-
+
assertFalse(nodeTen.isWildcarded());
assertFalse(nodeOne.isWildcarded());
assertTrue(nodes.containsWildcarded(nodeOne));
assertTrue(wildcarded.containsWildcarded(nodeOne));
assertTrue(wildcarded.containsWildcarded(nodeTen));
-
-
+
+
InstanceIdentifier<NodeChild> nodeTenChildWildcarded = InstanceIdentifier.builder(Nodes.class) //
.child(Node.class,new NodeKey(10)).child(NodeChild.class).toInstance();
-
+
assertTrue(nodeTenChildWildcarded.isWildcarded());
-
+
InstanceIdentifier<NodeChild> nodeTenChild = InstanceIdentifier.builder(Nodes.class) //
.child(Node.class,new NodeKey(10)).child(NodeChild.class, new NodeChildKey(10)).toInstance();
InstanceIdentifier<NodeChild> nodeOneChild = InstanceIdentifier.builder(Nodes.class) //
.child(Node.class,new NodeKey(1)).child(NodeChild.class, new NodeChildKey(1)).toInstance();
-
+
assertFalse(nodeTenChildWildcarded.containsWildcarded(nodeOneChild));
assertTrue(nodeTenChildWildcarded.containsWildcarded(nodeTenChild));
-
+
}
-
-
+
+
void childOfTest() {
InstanceIdentifier.builder(Nodes.class).child(InstantiatedFoo.class).child(FooChild.class);
}
public class NodeChildKey implements //
Identifier<NodeChild> {
-
- private final int id;
+ private static final long serialVersionUID = 1L;
+ private final int id;
public NodeChildKey(int id) {
super();
public class NodeKey implements //
Identifier<Node> {
-
- private final int id;
+ private static final long serialVersionUID = 1L;
+ private final int id;
public NodeKey(int id) {
super();
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.impl.schema.transform;
+
+import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
+import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+
+/**
+ * Factory for different normalized node serializers.
+ *
+ * @param <E>
+ * type of resulting/serialized element from NormalizedNode
+ */
+public interface FromNormalizedNodeSerializerFactory<E> {
+ FromNormalizedNodeSerializer<E, AugmentationNode, AugmentationSchema> getAugmentationNodeSerializer();
+ FromNormalizedNodeSerializer<E, ChoiceNode, org.opendaylight.yangtools.yang.model.api.ChoiceNode> getChoiceNodeSerializer();
+ FromNormalizedNodeSerializer<E, ContainerNode, ContainerSchemaNode> getContainerNodeSerializer();
+ FromNormalizedNodeSerializer<E, LeafNode<?>, LeafSchemaNode> getLeafNodeSerializer();
+ FromNormalizedNodeSerializer<E, LeafSetEntryNode<?>, LeafListSchemaNode> getLeafSetEntryNodeSerializer();
+ FromNormalizedNodeSerializer<E, LeafSetNode<?>, LeafListSchemaNode> getLeafSetNodeSerializer();
+ FromNormalizedNodeSerializer<E, MapEntryNode, ListSchemaNode> getMapEntryNodeSerializer();
+ FromNormalizedNodeSerializer<E, MapNode, ListSchemaNode> getMapNodeSerializer();
+}
* @return NormalizedNode as a result of parsing list of E elements with schema S
*/
N parse(Iterable<E> xmlDom, S schema);
-
-
}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.impl.schema.transform;
+
+import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
+import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+
+/**
+ * Factory for different normalized node parsers.
+ *
+ * @param <E>
+ * type of element to be parsed into NormalizedNode
+ */
+public interface ToNormalizedNodeParserFactory<E> {
+ ToNormalizedNodeParser<E, AugmentationNode, AugmentationSchema> getAugmentationNodeParser();
+ ToNormalizedNodeParser<E, ChoiceNode, org.opendaylight.yangtools.yang.model.api.ChoiceNode> getChoiceNodeParser();
+ ToNormalizedNodeParser<E, ContainerNode, ContainerSchemaNode> getContainerNodeParser();
+ ToNormalizedNodeParser<E, LeafNode<?>, LeafSchemaNode> getLeafNodeParser();
+ ToNormalizedNodeParser<E, LeafSetEntryNode<?>, LeafListSchemaNode> getLeafSetEntryNodeParser();
+ ToNormalizedNodeParser<E, LeafSetNode<?>, LeafListSchemaNode> getLeafSetNodeParser();
+ ToNormalizedNodeParser<E, MapEntryNode, ListSchemaNode> getMapEntryNodeParser();
+ ToNormalizedNodeParser<E, MapNode, ListSchemaNode> getMapNodeParser();
+}
import java.util.List;
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
-import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
-import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
-import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
-import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParserFactory;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
* The same instance of parser can be provided in case it is immutable.
*/
public static abstract class BaseNodeParserDispatcher<E> implements NodeParserDispatcher<E> {
+ private final ToNormalizedNodeParserFactory<E> factory;
+
+ protected BaseNodeParserDispatcher(final ToNormalizedNodeParserFactory<E> factory) {
+ this.factory = Preconditions.checkNotNull(factory);
+ }
@Override
public final DataContainerChild<?, ?> dispatchChildElement(Object schema, List<E> childNodes) {
Preconditions.checkArgument(childNodes.isEmpty() == false);
if (schema instanceof ContainerSchemaNode) {
- return getContainerNodeParser().parse(childNodes, (ContainerSchemaNode) schema);
+ return factory.getContainerNodeParser().parse(childNodes, (ContainerSchemaNode) schema);
} else if (schema instanceof LeafSchemaNode) {
- return getLeafNodeParser().parse(childNodes, (LeafSchemaNode) schema);
+ return factory.getLeafNodeParser().parse(childNodes, (LeafSchemaNode) schema);
} else if (schema instanceof LeafListSchemaNode) {
- return getLeafSetNodeParser().parse(childNodes, (LeafListSchemaNode) schema);
+ return factory.getLeafSetNodeParser().parse(childNodes, (LeafListSchemaNode) schema);
} else if (schema instanceof ListSchemaNode) {
- return getMapNodeParser().parse(childNodes, (ListSchemaNode) schema);
+ return factory.getMapNodeParser().parse(childNodes, (ListSchemaNode) schema);
} else if (schema instanceof ChoiceNode) {
- return getChoiceNodeParser().parse(childNodes, (ChoiceNode) schema);
+ return factory.getChoiceNodeParser().parse(childNodes, (ChoiceNode) schema);
} else if (schema instanceof AugmentationSchema) {
- return getAugmentationNodeParser().parse(childNodes, (AugmentationSchema) schema);
+ return factory.getAugmentationNodeParser().parse(childNodes, (AugmentationSchema) schema);
}
throw new IllegalArgumentException("Unable to parse node, unknown schema type: " + schema.getClass());
}
-
- protected abstract ToNormalizedNodeParser<E, ContainerNode, ContainerSchemaNode> getContainerNodeParser();
-
- protected abstract ToNormalizedNodeParser<E, LeafNode<?>, LeafSchemaNode> getLeafNodeParser();
-
- protected abstract ToNormalizedNodeParser<E, LeafSetNode<?>, LeafListSchemaNode> getLeafSetNodeParser();
-
- protected abstract ToNormalizedNodeParser<E, MapNode, ListSchemaNode> getMapNodeParser();
-
- protected abstract ToNormalizedNodeParser<E, org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode, ChoiceNode> getChoiceNodeParser();
-
- protected abstract ToNormalizedNodeParser<E, AugmentationNode, AugmentationSchema> getAugmentationNodeParser();
-
}
}
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.MixinNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.transform.FromNormalizedNodeSerializer;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.FromNormalizedNodeSerializerFactory;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
* The same instance of serializer can be provided in case it is immutable.
*/
public static abstract class BaseNodeSerializerDispatcher<E> implements NodeSerializerDispatcher<E> {
+ private final FromNormalizedNodeSerializerFactory<E> factory;
+
+ protected BaseNodeSerializerDispatcher(final FromNormalizedNodeSerializerFactory<E> factory) {
+ this.factory = Preconditions.checkNotNull(factory);
+ }
@Override
public final Iterable<E> dispatchChildElement(Object childSchema,
private Iterable<E> onAugmentationSchema(Object childSchema,
DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, AugmentationSchema.class, dataContainerChild);
- return getAugmentationNodeSerializer().serialize((AugmentationSchema) childSchema,
+ return factory.getAugmentationNodeSerializer().serialize((AugmentationSchema) childSchema,
(AugmentationNode) dataContainerChild);
}
DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, org.opendaylight.yangtools.yang.model.api.ChoiceNode.class,
dataContainerChild);
- return getChoiceNodeSerializer()
+ return factory.getChoiceNodeSerializer()
.serialize((org.opendaylight.yangtools.yang.model.api.ChoiceNode) childSchema,
(ChoiceNode) dataContainerChild);
}
private Iterable<E> onListNode(Object childSchema,
DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, ListSchemaNode.class, dataContainerChild);
- return getMapNodeSerializer().serialize((ListSchemaNode) childSchema, (MapNode) dataContainerChild);
+ return factory.getMapNodeSerializer().serialize((ListSchemaNode) childSchema, (MapNode) dataContainerChild);
}
private Iterable<E> onLeafListNode(Object childSchema,
DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, LeafListSchemaNode.class, dataContainerChild);
- return getLeafSetNodeSerializer().serialize((LeafListSchemaNode) childSchema,
+ return factory.getLeafSetNodeSerializer().serialize((LeafListSchemaNode) childSchema,
(LeafSetNode<?>) dataContainerChild);
}
private Iterable<E> onLeafNode(Object childSchema,
DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, LeafSchemaNode.class, dataContainerChild);
- Iterable<E> elements = getLeafNodeSerializer().serialize((LeafSchemaNode) childSchema,
+ Iterable<E> elements = factory.getLeafNodeSerializer().serialize((LeafSchemaNode) childSchema,
(LeafNode<?>) dataContainerChild);
checkOnlyOneSerializedElement(elements, dataContainerChild);
return elements;
DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, ContainerSchemaNode.class, dataContainerChild);
- Iterable<E> elements = getContainerNodeSerializer().serialize((ContainerSchemaNode) childSchema,
+ Iterable<E> elements = factory.getContainerNodeSerializer().serialize((ContainerSchemaNode) childSchema,
(ContainerNode) dataContainerChild);
checkOnlyOneSerializedElement(elements, dataContainerChild);
return elements;
"Incompatible schema: %s with node: %s, expected: %s", childSchema, dataContainerChild,
containerSchemaNodeClass);
}
-
- protected abstract FromNormalizedNodeSerializer<E, ContainerNode, ContainerSchemaNode> getContainerNodeSerializer();
-
- protected abstract FromNormalizedNodeSerializer<E, LeafNode<?>, LeafSchemaNode> getLeafNodeSerializer();
-
- protected abstract FromNormalizedNodeSerializer<E, LeafSetNode<?>, LeafListSchemaNode> getLeafSetNodeSerializer();
-
- protected abstract FromNormalizedNodeSerializer<E, MapNode, ListSchemaNode> getMapNodeSerializer();
-
- protected abstract FromNormalizedNodeSerializer<E, org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode, org.opendaylight.yangtools.yang.model.api.ChoiceNode> getChoiceNodeSerializer();
-
- protected abstract FromNormalizedNodeSerializer<E, AugmentationNode, AugmentationSchema> getAugmentationNodeSerializer();
}
}
package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlCodecProvider;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.AugmentationNodeBaseParser;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils;
import com.google.common.base.Preconditions;
import com.google.common.collect.LinkedListMultimap;
-public final class AugmentationNodeDomParser extends AugmentationNodeBaseParser<Element> {
+final class AugmentationNodeDomParser extends AugmentationNodeBaseParser<Element> {
- private final XmlCodecProvider codecProvider;
+ private final NodeParserDispatcher<Element> dispatcher;
- public AugmentationNodeDomParser(XmlCodecProvider codecProvider) {
- this.codecProvider = Preconditions.checkNotNull(codecProvider);
+ AugmentationNodeDomParser(final NodeParserDispatcher<Element> dispatcher) {
+ this.dispatcher = Preconditions.checkNotNull(dispatcher);
}
@Override
@Override
protected NodeParserDispatcher<Element> getDispatcher() {
- return DomNodeDispatcher.getInstance(codecProvider);
+ return dispatcher;
}
}
package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlCodecProvider;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.ChoiceNodeBaseParser;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils;
import com.google.common.base.Preconditions;
import com.google.common.collect.LinkedListMultimap;
-public final class ChoiceNodeDomParser extends ChoiceNodeBaseParser<Element> {
+final class ChoiceNodeDomParser extends ChoiceNodeBaseParser<Element> {
- private final XmlCodecProvider codecProvider;
+ private final NodeParserDispatcher<Element> dispatcher;
- public ChoiceNodeDomParser(XmlCodecProvider codecProvider) {
- this.codecProvider = Preconditions.checkNotNull(codecProvider);
+ ChoiceNodeDomParser(NodeParserDispatcher<Element> dispatcher) {
+ this.dispatcher = Preconditions.checkNotNull(dispatcher);
}
@Override
@Override
protected NodeParserDispatcher<Element> getDispatcher() {
- return DomNodeDispatcher.getInstance(codecProvider);
+ return dispatcher;
}
-
}
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlCodecProvider;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.ContainerNodeBaseParser;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils;
import com.google.common.base.Preconditions;
import com.google.common.collect.LinkedListMultimap;
-public final class ContainerNodeDomParser extends ContainerNodeBaseParser<Element> {
+final class ContainerNodeDomParser extends ContainerNodeBaseParser<Element> {
- private final XmlCodecProvider codecProvider;
+ private final NodeParserDispatcher<Element> dispatcher;
- public ContainerNodeDomParser(XmlCodecProvider codecProvider) {
- this.codecProvider = Preconditions.checkNotNull(codecProvider);
+ ContainerNodeDomParser(final NodeParserDispatcher<Element> dispatcher) {
+ this.dispatcher = Preconditions.checkNotNull(dispatcher);
}
+
@Override
protected Map<QName, String> getAttributes(Element element) {
return DomUtils.toAttributes(element.getAttributes());
@Override
protected NodeParserDispatcher<Element> getDispatcher() {
- return DomNodeDispatcher.getInstance(codecProvider);
+ return dispatcher;
}
@Override
+++ /dev/null
-package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser;
-
-import org.opendaylight.yangtools.yang.data.api.schema.*;
-import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlCodecProvider;
-import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser;
-import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher;
-import org.opendaylight.yangtools.yang.model.api.*;
-import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
-import org.w3c.dom.Element;
-
-public class DomNodeDispatcher extends NodeParserDispatcher.BaseNodeParserDispatcher<Element> {
-
- private final ContainerNodeDomParser containerNodeDomParser;
- private final LeafNodeDomParser leafNodeDomParser;
- private final LeafSetNodeDomParser leafSetNodeDomParser;
- private final MapNodeDomParser mapNodeDomParser;
- private final ChoiceNodeDomParser choiceNodeDomParser;
- private final AugmentationNodeDomParser augmentationNodeDomParser;
-
- private static DomNodeDispatcher instance = null;
-
- private DomNodeDispatcher(XmlCodecProvider codecProvider) {
- leafNodeDomParser = new LeafNodeDomParser(codecProvider);
- containerNodeDomParser = new ContainerNodeDomParser(codecProvider);
- leafSetNodeDomParser = new LeafSetNodeDomParser(new LeafSetEntryNodeDomParser(codecProvider));
- mapNodeDomParser = new MapNodeDomParser(new MapEntryNodeDomParser(codecProvider));
- choiceNodeDomParser = new ChoiceNodeDomParser(codecProvider);
- augmentationNodeDomParser = new AugmentationNodeDomParser(codecProvider);
- }
-
- @Override
- protected ToNormalizedNodeParser<Element, ContainerNode, ContainerSchemaNode> getContainerNodeParser() {
- return containerNodeDomParser;
- }
-
- @Override
- protected ToNormalizedNodeParser<Element, LeafNode<?>, LeafSchemaNode> getLeafNodeParser() {
- return leafNodeDomParser;
- }
-
- @Override
- protected ToNormalizedNodeParser<Element, LeafSetNode<?>, LeafListSchemaNode> getLeafSetNodeParser() {
- return leafSetNodeDomParser;
- }
-
- @Override
- protected ToNormalizedNodeParser<Element, MapNode, ListSchemaNode> getMapNodeParser() {
- return mapNodeDomParser;
- }
-
- @Override
- protected ToNormalizedNodeParser<Element, org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode, ChoiceNode> getChoiceNodeParser() {
- return choiceNodeDomParser;
- }
-
- @Override
- protected ToNormalizedNodeParser<Element, AugmentationNode, AugmentationSchema> getAugmentationNodeParser() {
- return augmentationNodeDomParser;
- }
-
- public static NodeParserDispatcher<Element> getInstance(XmlCodecProvider codecProvider) {
- if (instance == null) {
- instance = new DomNodeDispatcher(codecProvider);
- }
- return instance;
- }
-}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser;
+
+import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
+import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlCodecProvider;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParserFactory;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher;
+import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+import org.w3c.dom.Element;
+
+public final class DomToNormalizedNodeParserFactory implements ToNormalizedNodeParserFactory<Element> {
+ private final AugmentationNodeDomParser augmentationNodeParser;
+ private final ChoiceNodeDomParser choiceNodeParser;
+ private final ContainerNodeDomParser containerNodeParser;
+ private final LeafNodeDomParser leafNodeParser;
+ private final LeafSetEntryNodeDomParser leafSetEntryNodeParser;
+ private final LeafSetNodeDomParser leafSetNodeParser;
+ private final MapNodeDomParser mapNodeParser;
+ private final MapEntryNodeDomParser mapEntryNodeParser;
+
+ private DomToNormalizedNodeParserFactory(final XmlCodecProvider codecProvider) {
+ leafNodeParser = new LeafNodeDomParser(codecProvider);
+ leafSetEntryNodeParser = new LeafSetEntryNodeDomParser(codecProvider);
+ leafSetNodeParser = new LeafSetNodeDomParser(leafSetEntryNodeParser);
+
+ final NodeParserDispatcher<Element> dispatcher = new NodeParserDispatcher.BaseNodeParserDispatcher<Element>(this) {
+
+ };
+
+ containerNodeParser = new ContainerNodeDomParser(dispatcher);
+ mapEntryNodeParser = new MapEntryNodeDomParser(dispatcher);
+ mapNodeParser = new MapNodeDomParser(mapEntryNodeParser);
+ choiceNodeParser = new ChoiceNodeDomParser(dispatcher);
+ augmentationNodeParser = new AugmentationNodeDomParser(dispatcher);
+ }
+
+ public static DomToNormalizedNodeParserFactory getInstance(final XmlCodecProvider codecProvider) {
+ return new DomToNormalizedNodeParserFactory(codecProvider);
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Element, AugmentationNode, AugmentationSchema> getAugmentationNodeParser() {
+ return augmentationNodeParser;
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Element, ChoiceNode, org.opendaylight.yangtools.yang.model.api.ChoiceNode> getChoiceNodeParser() {
+ return choiceNodeParser;
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Element, ContainerNode, ContainerSchemaNode> getContainerNodeParser() {
+ return containerNodeParser;
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Element, LeafNode<?>, LeafSchemaNode> getLeafNodeParser() {
+ return leafNodeParser;
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Element, LeafSetEntryNode<?>, LeafListSchemaNode> getLeafSetEntryNodeParser() {
+ return leafSetEntryNodeParser;
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Element, LeafSetNode<?>, LeafListSchemaNode> getLeafSetNodeParser() {
+ return leafSetNodeParser;
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Element, MapEntryNode, ListSchemaNode> getMapEntryNodeParser() {
+ return mapEntryNodeParser;
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Element, MapNode, ListSchemaNode> getMapNodeParser() {
+ return mapNodeParser;
+ }
+}
import com.google.common.base.Preconditions;
-public class LeafNodeDomParser extends LeafNodeBaseParser<Element> {
+final class LeafNodeDomParser extends LeafNodeBaseParser<Element> {
private final XmlCodecProvider codecProvider;
- public LeafNodeDomParser(XmlCodecProvider codecProvider) {
+ LeafNodeDomParser(XmlCodecProvider codecProvider) {
this.codecProvider = Preconditions.checkNotNull(codecProvider);
}
import java.util.Map;
-import com.google.common.base.Preconditions;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlCodecProvider;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.LeafSetEntryNodeBaseParser;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.w3c.dom.Element;
-public class LeafSetEntryNodeDomParser extends LeafSetEntryNodeBaseParser<Element> {
+import com.google.common.base.Preconditions;
+
+final class LeafSetEntryNodeDomParser extends LeafSetEntryNodeBaseParser<Element> {
private final XmlCodecProvider codecProvider;
- public LeafSetEntryNodeDomParser(XmlCodecProvider codecProvider) {
+ LeafSetEntryNodeDomParser(XmlCodecProvider codecProvider) {
this.codecProvider = Preconditions.checkNotNull(codecProvider);
}
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.w3c.dom.Element;
-public class LeafSetNodeDomParser extends LeafSetNodeBaseParser<Element> {
+final class LeafSetNodeDomParser extends LeafSetNodeBaseParser<Element> {
private final LeafSetEntryNodeDomParser leafSetEntryNodeBaseParser;
- public LeafSetNodeDomParser(LeafSetEntryNodeDomParser leafSetEntryNodeBaseParser) {
+ LeafSetNodeDomParser(LeafSetEntryNodeDomParser leafSetEntryNodeBaseParser) {
this.leafSetEntryNodeBaseParser = leafSetEntryNodeBaseParser;
}
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlCodecProvider;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.MapEntryNodeBaseParser;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils;
import com.google.common.base.Preconditions;
import com.google.common.collect.LinkedListMultimap;
-public final class MapEntryNodeDomParser extends MapEntryNodeBaseParser<Element> {
+final class MapEntryNodeDomParser extends MapEntryNodeBaseParser<Element> {
- private final XmlCodecProvider codecProvider;
+ private final NodeParserDispatcher<Element> dispatcher;
- public MapEntryNodeDomParser(XmlCodecProvider codecProvider) {
- this.codecProvider = Preconditions.checkNotNull(codecProvider);
+ MapEntryNodeDomParser(final NodeParserDispatcher<Element> dispatcher) {
+ this.dispatcher = Preconditions.checkNotNull(dispatcher);
}
@Override
@Override
protected NodeParserDispatcher<Element> getDispatcher() {
- return DomNodeDispatcher.getInstance(codecProvider);
+ return dispatcher;
}
@Override
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.w3c.dom.Element;
-public final class MapNodeDomParser extends MapNodeBaseParser<Element> {
+final class MapNodeDomParser extends MapNodeBaseParser<Element> {
private final MapEntryNodeDomParser mapEntryParser;
- public MapNodeDomParser(MapEntryNodeDomParser mapEntryParser) {
+ MapNodeDomParser(MapEntryNodeDomParser mapEntryParser) {
this.mapEntryParser = mapEntryParser;
}
import com.google.common.base.Preconditions;
-public class AugmentationNodeDomSerializer extends
+final class AugmentationNodeDomSerializer extends
AugmentationNodeBaseSerializer<Element> {
private final NodeSerializerDispatcher<Element> dispatcher;
- public AugmentationNodeDomSerializer(NodeSerializerDispatcher<Element> dispatcher) {
+ AugmentationNodeDomSerializer(NodeSerializerDispatcher<Element> dispatcher) {
this.dispatcher = Preconditions.checkNotNull(dispatcher);
}
import com.google.common.base.Preconditions;
-public class ChoiceNodeDomSerializer extends ChoiceNodeBaseSerializer<Element> {
+final class ChoiceNodeDomSerializer extends ChoiceNodeBaseSerializer<Element> {
private final NodeSerializerDispatcher<Element> dispatcher;
- public ChoiceNodeDomSerializer(final NodeSerializerDispatcher<Element> dispatcher) {
+ ChoiceNodeDomSerializer(final NodeSerializerDispatcher<Element> dispatcher) {
this.dispatcher = Preconditions.checkNotNull(dispatcher);
}
import com.google.common.base.Preconditions;
-public class ContainerNodeDomSerializer extends
+final class ContainerNodeDomSerializer extends
ContainerNodeBaseSerializer<Element> {
- private final Document doc;
private final NodeSerializerDispatcher<Element> dispatcher;
+ private final Document doc;
- public ContainerNodeDomSerializer(final Document doc, final NodeSerializerDispatcher<Element> dispatcher) {
+ ContainerNodeDomSerializer(final Document doc, final NodeSerializerDispatcher<Element> dispatcher) {
this.doc = Preconditions.checkNotNull(doc);
this.dispatcher = Preconditions.checkNotNull(dispatcher);
}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.serializer;
+
+import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
+import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlCodecProvider;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.FromNormalizedNodeSerializer;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.FromNormalizedNodeSerializerFactory;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.NodeSerializerDispatcher;
+import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+public final class DomFromNormalizedNodeSerializerFactory implements FromNormalizedNodeSerializerFactory<Element> {
+ private final ContainerNodeDomSerializer containerSerializer;
+ private final ChoiceNodeDomSerializer choiceSerializer;
+ private final AugmentationNodeDomSerializer augmentSerializer;
+ private final LeafNodeDomSerializer leafNodeSerializer;
+ private final LeafSetNodeDomSerializer leafSetSerializer;
+ private final MapNodeDomSerializer mapNodeSerializer;
+ private final LeafSetEntryNodeDomSerializer leafSetEntryNodeSerializer;
+ private final MapEntryNodeDomSerializer mapEntryNodeSerializer;
+
+ private DomFromNormalizedNodeSerializerFactory(final Document doc, final XmlCodecProvider codecProvider) {
+ final NodeSerializerDispatcher.BaseNodeSerializerDispatcher<Element> dispatcher = new NodeSerializerDispatcher.BaseNodeSerializerDispatcher<Element>(this) {
+
+ };
+
+ containerSerializer = new ContainerNodeDomSerializer(doc, dispatcher);
+ choiceSerializer = new ChoiceNodeDomSerializer(dispatcher);
+ augmentSerializer = new AugmentationNodeDomSerializer(dispatcher);
+ leafNodeSerializer = new LeafNodeDomSerializer(doc, codecProvider);
+
+ leafSetEntryNodeSerializer = new LeafSetEntryNodeDomSerializer(doc, codecProvider);
+ leafSetSerializer = new LeafSetNodeDomSerializer(leafSetEntryNodeSerializer);
+
+ mapEntryNodeSerializer = new MapEntryNodeDomSerializer(doc, dispatcher);
+ mapNodeSerializer = new MapNodeDomSerializer(mapEntryNodeSerializer);
+ }
+
+ public static DomFromNormalizedNodeSerializerFactory getInstance(final Document doc, final XmlCodecProvider codecProvider) {
+ return new DomFromNormalizedNodeSerializerFactory(doc, codecProvider);
+ }
+
+ @Override
+ public FromNormalizedNodeSerializer<Element, AugmentationNode, AugmentationSchema> getAugmentationNodeSerializer() {
+ return augmentSerializer;
+ }
+
+ @Override
+ public FromNormalizedNodeSerializer<Element, ChoiceNode, org.opendaylight.yangtools.yang.model.api.ChoiceNode> getChoiceNodeSerializer() {
+ return choiceSerializer;
+ }
+
+ @Override
+ public FromNormalizedNodeSerializer<Element, ContainerNode, ContainerSchemaNode> getContainerNodeSerializer() {
+ return containerSerializer;
+ }
+
+ @Override
+ public FromNormalizedNodeSerializer<Element, LeafNode<?>, LeafSchemaNode> getLeafNodeSerializer() {
+ return leafNodeSerializer;
+ }
+
+ @Override
+ public FromNormalizedNodeSerializer<Element, LeafSetEntryNode<?>, LeafListSchemaNode> getLeafSetEntryNodeSerializer() {
+ return leafSetEntryNodeSerializer;
+ }
+
+ @Override
+ public FromNormalizedNodeSerializer<Element, LeafSetNode<?>, LeafListSchemaNode> getLeafSetNodeSerializer() {
+ return leafSetSerializer;
+ }
+
+ @Override
+ public FromNormalizedNodeSerializer<Element, MapEntryNode, ListSchemaNode> getMapEntryNodeSerializer() {
+ return mapEntryNodeSerializer;
+ }
+
+ @Override
+ public FromNormalizedNodeSerializer<Element, MapNode, ListSchemaNode> getMapNodeSerializer() {
+ return mapNodeSerializer;
+ }
+
+}
+++ /dev/null
-/*
- * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.serializer;
-
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutionException;
-
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
-import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
-import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
-import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
-import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
-import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlCodecProvider;
-import org.opendaylight.yangtools.yang.data.impl.schema.transform.FromNormalizedNodeSerializer;
-import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.NodeSerializerDispatcher;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.w3c.dom.Document;
-import org.w3c.dom.Element;
-
-import com.google.common.cache.Cache;
-import com.google.common.cache.CacheBuilder;
-
-final class DomNodeSerializerDispatcher extends NodeSerializerDispatcher.BaseNodeSerializerDispatcher<Element> {
- private static final Cache<Document, DomNodeSerializerDispatcher> dispatcherCache =
- CacheBuilder.newBuilder().weakKeys().build();
-
- private final FromNormalizedNodeSerializer<Element, ContainerNode, ContainerSchemaNode> containerSerializer;
- private final FromNormalizedNodeSerializer<Element, ChoiceNode, org.opendaylight.yangtools.yang.model.api.ChoiceNode> choiceSerializer;
- private final FromNormalizedNodeSerializer<Element, AugmentationNode, AugmentationSchema> augmentSerializer;
- private final FromNormalizedNodeSerializer<Element, LeafNode<?>, LeafSchemaNode> leafNodeSerializer;
- private final FromNormalizedNodeSerializer<Element, LeafSetNode<?>, LeafListSchemaNode> leafSetSerializer;
- private final FromNormalizedNodeSerializer<Element, MapNode, ListSchemaNode> mapNodeSerializer;
-
- DomNodeSerializerDispatcher(Document doc, XmlCodecProvider codecProvider) {
- containerSerializer = new ContainerNodeDomSerializer(doc, this);
- choiceSerializer = new ChoiceNodeDomSerializer(this);
- augmentSerializer = new AugmentationNodeDomSerializer(this);
- leafNodeSerializer = new LeafNodeDomSerializer(doc, codecProvider);
- leafSetSerializer = new LeafSetNodeDomSerializer(new LeafSetEntryNodeDomSerializer(doc, codecProvider));
- mapNodeSerializer = new MapNodeDomSerializer(new MapEntryNodeDomSerializer(doc, this));
- }
-
- // FIXME: Callers should really grow a proper (per-document) lifecycle and not rely on this
- @Deprecated
- static DomNodeSerializerDispatcher getInstance(final Document doc, final XmlCodecProvider codecProvider) {
- // DOM does not allow to add elements to one document from another, so maintain a cache
- // on a per-document case.
- try {
- return dispatcherCache.get(doc, new Callable<DomNodeSerializerDispatcher>() {
- @Override
- public DomNodeSerializerDispatcher call() {
- return new DomNodeSerializerDispatcher(doc, codecProvider);
- }
- });
- } catch (ExecutionException e) {
- throw new IllegalStateException("Failed to instantiated a dispatcher", e);
- }
- }
-
- @Override
- protected FromNormalizedNodeSerializer<Element, ContainerNode, ContainerSchemaNode> getContainerNodeSerializer() {
- return containerSerializer;
- }
-
- @Override
- protected FromNormalizedNodeSerializer<Element, LeafNode<?>, LeafSchemaNode> getLeafNodeSerializer() {
- return leafNodeSerializer;
- }
-
- @Override
- protected FromNormalizedNodeSerializer<Element, LeafSetNode<?>, LeafListSchemaNode> getLeafSetNodeSerializer() {
- return leafSetSerializer;
- }
-
- @Override
- protected FromNormalizedNodeSerializer<Element, MapNode, ListSchemaNode> getMapNodeSerializer() {
- return mapNodeSerializer;
- }
-
- @Override
- protected FromNormalizedNodeSerializer<Element, ChoiceNode, org.opendaylight.yangtools.yang.model.api.ChoiceNode> getChoiceNodeSerializer() {
- return choiceSerializer;
- }
-
- @Override
- protected FromNormalizedNodeSerializer<Element, AugmentationNode, AugmentationSchema> getAugmentationNodeSerializer() {
- return augmentSerializer;
- }
-}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.serializer;
-import com.google.common.base.Preconditions;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlCodecProvider;
import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlDocumentUtils;
-import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.LeafNodeBaseSerializer;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-public class LeafNodeDomSerializer extends LeafNodeBaseSerializer<Element> {
+import com.google.common.base.Preconditions;
- private final Document doc;
+final class LeafNodeDomSerializer extends LeafNodeBaseSerializer<Element> {
private final XmlCodecProvider codecProvider;
+ private final Document doc;
- public LeafNodeDomSerializer(Document doc, XmlCodecProvider codecProvider) {
+ LeafNodeDomSerializer(Document doc, XmlCodecProvider codecProvider) {
this.doc = Preconditions.checkNotNull(doc);
this.codecProvider = Preconditions.checkNotNull(codecProvider);
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.serializer;
-import com.google.common.base.Preconditions;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlCodecProvider;
import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlDocumentUtils;
-import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.LeafSetEntryNodeBaseSerializer;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-public class LeafSetEntryNodeDomSerializer extends
+import com.google.common.base.Preconditions;
+
+final class LeafSetEntryNodeDomSerializer extends
LeafSetEntryNodeBaseSerializer<Element> {
private final Document doc;
private final XmlCodecProvider codecProvider;
- public LeafSetEntryNodeDomSerializer(Document doc, XmlCodecProvider codecProvider) {
+ LeafSetEntryNodeDomSerializer(Document doc, XmlCodecProvider codecProvider) {
this.doc = Preconditions.checkNotNull(doc);
this.codecProvider = Preconditions.checkNotNull(codecProvider);
}
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.w3c.dom.Element;
-public class LeafSetNodeDomSerializer extends
- LeafSetNodeBaseSerializer<Element> {
-
+final class LeafSetNodeDomSerializer extends LeafSetNodeBaseSerializer<Element> {
private final FromNormalizedNodeSerializer<Element, LeafSetEntryNode<?>, LeafListSchemaNode> leafSetEntryNodeSerializer;
- public LeafSetNodeDomSerializer(LeafSetEntryNodeDomSerializer leafSetEntryNodeSerializer) {
+ LeafSetNodeDomSerializer(LeafSetEntryNodeDomSerializer leafSetEntryNodeSerializer) {
this.leafSetEntryNodeSerializer = leafSetEntryNodeSerializer;
}
import com.google.common.base.Preconditions;
-public class MapEntryNodeDomSerializer extends
- MapEntryNodeBaseSerializer<Element> {
-
- private final Document doc;
+final class MapEntryNodeDomSerializer extends MapEntryNodeBaseSerializer<Element> {
private final NodeSerializerDispatcher<Element> dispatcher;
+ private final Document doc;
- public MapEntryNodeDomSerializer(final Document doc, final NodeSerializerDispatcher<Element> dispatcher) {
+ MapEntryNodeDomSerializer(final Document doc, final NodeSerializerDispatcher<Element> dispatcher) {
this.doc = Preconditions.checkNotNull(doc);
this.dispatcher = Preconditions.checkNotNull(dispatcher);
}
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.w3c.dom.Element;
-public class MapNodeDomSerializer extends MapNodeBaseSerializer<Element> {
+final class MapNodeDomSerializer extends MapNodeBaseSerializer<Element> {
private final FromNormalizedNodeSerializer<Element, MapEntryNode, ListSchemaNode> mapEntrySerializer;
- public MapNodeDomSerializer(MapEntryNodeDomSerializer mapEntrySerializer) {
+ MapNodeDomSerializer(MapEntryNodeDomSerializer mapEntrySerializer) {
this.mapEntrySerializer = mapEntrySerializer;
}
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.NodeSerializerDispatcher;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils;
-import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser.ContainerNodeDomParser;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser.DomToNormalizedNodeParserFactory;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
public void testTranslation() throws Exception {
Document doc = loadDocument(xmlPath);
- ContainerNode built = new ContainerNodeDomParser(DomUtils.defaultValueCodecProvider()).parse(
+ ContainerNode built =
+ DomToNormalizedNodeParserFactory.getInstance(DomUtils.defaultValueCodecProvider()).getContainerNodeParser().parse(
Collections.singletonList(doc.getDocumentElement()), containerNode);
if (expectedNode != null)
logger.info("{}", built);
- final Document newDoc = XmlDocumentUtils.getDocument();
- final NodeSerializerDispatcher<Element> dispatcher = new DomNodeSerializerDispatcher(newDoc, DomUtils.defaultValueCodecProvider());
-
- Iterable<Element> els = new ContainerNodeDomSerializer(newDoc,
- dispatcher).serialize(containerNode, built);
+ Iterable<Element> els = DomFromNormalizedNodeSerializerFactory.getInstance(XmlDocumentUtils.getDocument(), DomUtils.defaultValueCodecProvider())
+ .getContainerNodeSerializer().serialize(containerNode, built);
Element el = els.iterator().next();
Code Review / yangtools.git / commitdiff