import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
/**
* Composite node represents a branch in the data tree, which could contain
* <li><b>anyxml</b></li>
* </ul>
*
- *
+ * @deprecated Use {@link NormalizedNodeContainer} instead.
*/
-public interface CompositeNode extends //
- Node<List<Node<?>>>, //
- NodeModification, //
- Map<QName,List<Node<?>>> {
+@Deprecated
+public interface CompositeNode extends Node<List<Node<?>>>, NodeModification, Map<QName,List<Node<?>>> {
/**
* Returns a list of children as seens in resulting XML serialization
import java.util.List;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
+
/**
* @author michal.rehak
*
+ * @deprecated Deprecated in favor of {@link NormalizedNodeContainer} classes.
*/
+@Deprecated
public interface MutableCompositeNode extends MutableNode<List<Node<?>>>, CompositeNode {
/**
package org.opendaylight.yangtools.yang.data.api;
import org.opendaylight.yangtools.concepts.Mutable;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
/**
*
*
* @param <T>
+ *
+ * @deprecated Use {@link NormalizedNode} instead.
*/
+@Deprecated
public interface MutableNode<T> extends Node<T>,Mutable {
/**
*/
package org.opendaylight.yangtools.yang.data.api;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+
/**
* @author michal.rehak
* @param <T> node value type
*
+ * @deprecated Use {@link NormalizedNode} instead.
*/
+@Deprecated
public interface MutableSimpleNode<T> extends MutableNode<T>, SimpleNode<T> {
-
+
/**
* @return original node, if available
*/
SimpleNode<T> getOriginal();
-
+
}
*/
package org.opendaylight.yangtools.yang.data.api;
+
/**
* @author michal.rehak
- *
+ *
+ * @deprecated Use {@link NormalizedNodeUtils} instead.
*/
+@Deprecated
public interface NodeModificationBuilder {
abstract Node<?> getMutableEquivalent(Node<?> originalNode);
*/
package org.opendaylight.yangtools.yang.data.api;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+
/**
* Simple node represents a leaf in the data tree, which does not contain any
* nested nodes, but the value of node. In the terms of the XML the simple node
* the empty type, which in XML form is similar to the empty container.</li>
* <li><b>item</b> in <b>leaf-list</b></li>
* </ul>
- *
- *
+ *
+ *
* @param <T>
+ *
+ * @deprecated Use {@link NormalizedNode} instead.
*/
+@Deprecated
public interface SimpleNode<T> extends Node<T>, NodeModification {
/**
- * @return cast self to mutable, if possible
+ * @return cast self to mutable, if possible
*/
MutableSimpleNode<T> asMutable();
}
package org.opendaylight.yangtools.yang.data.impl;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.*;
+import org.opendaylight.yangtools.yang.data.api.CompositeNode;
+import org.opendaylight.yangtools.yang.data.api.ModifyAction;
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.NodeModification;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder;
/**
* @author michal.rehak
* @param <T>
* type of node value
- *
+ * @deprecated Use one of the {@link NormalizedNodeBuilder} implementations.
*/
+@Deprecated
public abstract class AbstractNodeTO<T> implements Node<T>, NodeModification {
private QName qName;
* @param parent
* @param value
*/
- public AbstractNodeTO(QName qname, CompositeNode parent, T value) {
+ public AbstractNodeTO(final QName qname, final CompositeNode parent, final T value) {
this(qname, parent, value, null);
}
* @param value
* @param modifyAction
*/
- public AbstractNodeTO(QName qname, CompositeNode parent, T value, ModifyAction modifyAction) {
+ public AbstractNodeTO(final QName qname, final CompositeNode parent, final T value, final ModifyAction modifyAction) {
this.qName = qname;
this.parent = parent;
this.value = value;
* @param parent
* the parent to set
*/
- public void setParent(CompositeNode parent) {
+ public void setParent(final CompositeNode parent) {
this.parent = parent;
}
* @param value
* the value to set
*/
- public T setValue(T value) {
+ @Override
+ public T setValue(final T value) {
T oldValue = this.value;
this.value = value;
return oldValue;
* @param modifyAction
* the modifyAction to set
*/
- protected void setModificationAction(ModifyAction modifyAction) {
+ protected void setModificationAction(final ModifyAction modifyAction) {
this.modifyAction = modifyAction;
}
}
@Override
- public boolean equals(Object obj) {
+ public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
//Serialization related
- protected final void init(QName qName, CompositeNode parent, T value, ModifyAction modifyAction){
+ protected final void init(final QName qName, final CompositeNode parent, final T value, final ModifyAction modifyAction){
this.qName = qName;
this.modifyAction = modifyAction;
this.parent = parent;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
import org.opendaylight.yangtools.yang.data.api.ModifyAction;
import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
/**
* @author michal.rehak
*
+ * @deprecated Use one of the {@link NormalizedNode} implementations.
*/
+@Deprecated
public class CompositeNodeModificationTOImpl extends CompositeNodeTOImpl {
private static final long serialVersionUID = 1L;
* @param value
* @param modifyAction
*/
- public CompositeNodeModificationTOImpl(QName qname, CompositeNode parent,
- List<Node<?>> value, ModifyAction modifyAction) {
+ public CompositeNodeModificationTOImpl(final QName qname, final CompositeNode parent,
+ final List<Node<?>> value, final ModifyAction modifyAction) {
super(qname, parent, value);
super.setModificationAction(modifyAction);
}
import org.opendaylight.yangtools.yang.data.api.MutableCompositeNode;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
/**
* @author michal.rehak
*
+ * @deprecated Use one of the {@link NormalizedNodeContainer} implementations.
*/
+@Deprecated
public class CompositeNodeTOImpl extends AbstractNodeTO<List<Node<?>>> implements CompositeNode, Serializable {
private static final long serialVersionUID = 100L;
import org.opendaylight.yangtools.yang.data.api.MutableCompositeNode;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
import org.opendaylight.yangtools.yang.data.impl.util.AbstractCompositeNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.util.CompositeNodeBuilder;
-public final class ImmutableCompositeNode extends AbstractNodeTO<List<Node<?>>> implements //
-Immutable, //
-CompositeNode, //
-AttributesContainer, //
-Serializable {
+/**
+ * @deprecated Use one of the {@link NormalizedNodeContainer} implementations.
+ */
+@Deprecated
+public final class ImmutableCompositeNode extends AbstractNodeTO<List<Node<?>>> implements Immutable, CompositeNode, AttributesContainer, Serializable {
private static final long serialVersionUID = 100L;
* @author michal.rehak
*
*/
+@Deprecated
public class LazyNodeToNodeMap {
private final Map<Node<?>, Node<?>> node2node = new HashMap<>();
import org.opendaylight.yangtools.yang.data.api.MutableCompositeNode;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
/**
* @author michal.rehak
*
+ * @deprecated Use one of the {@link NormalizedNodeContainer} implementations instead.
*/
+@Deprecated
public class MutableCompositeNodeTOImpl extends AbstractNodeTO<List<Node<?>>> implements MutableCompositeNode, Serializable {
private static final long serialVersionUID = 100L;
import org.opendaylight.yangtools.yang.data.api.ModifyAction;
import org.opendaylight.yangtools.yang.data.api.MutableSimpleNode;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
/**
* @author michal.rehak
* @param <T>
* type of simple node value
*
+ * @deprecated Use one of the {@link NormalizedNode} implementation packages.
*/
+@Deprecated
public class MutableSimpleNodeTOImpl<T> extends SimpleNodeTOImpl<T> implements MutableSimpleNode<T> {
private static final long serialVersionUID = 1L;
private SimpleNode<T> original;
* @param value
* @param modifyAction
*/
- public MutableSimpleNodeTOImpl(QName qname, CompositeNode parent, T value, ModifyAction modifyAction) {
+ public MutableSimpleNodeTOImpl(final QName qname, final CompositeNode parent, final T value, final ModifyAction modifyAction) {
super(qname, parent, value, modifyAction);
}
@Override
- public void setModifyAction(ModifyAction action) {
+ public void setModifyAction(final ModifyAction action) {
super.setModificationAction(action);
}
* @param original
* the original to set
*/
- public void setOriginal(SimpleNode<T> original) {
+ public void setOriginal(final SimpleNode<T> original) {
this.original = original;
}
}
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.NodeModification;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
/**
* @author michal.rehak
*
+ * @deprecated Use {@link Builders} instead.
*/
+@Deprecated
public abstract class NodeFactory {
/**
import org.opendaylight.yangtools.yang.data.api.MutableSimpleNode;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.NodeModificationBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
/**
* @author michal.rehak
*
+ * @deprecated Use {@link Builders} instead.
*/
+@Deprecated
public class NodeModificationBuilderImpl implements NodeModificationBuilder {
private final SchemaContext context;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.NodeModification;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeUtils;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
/**
* @author michal.rehak
*
+ * @deprecated Use {@link NormalizedNodeUtils} instead.
*/
+@Deprecated
public abstract class NodeUtils {
private static final Joiner DOT_JOINER = Joiner.on(".");
private static final Logger LOG = LoggerFactory.getLogger(NodeUtils.class);
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
import org.opendaylight.yangtools.yang.data.api.ModifyAction;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
/**
* @author michal.rehak
* @param <T> type of node value
*
+ * @deprecated Use one of the {@link NormalizedNode} implementation packages.
*/
+@Deprecated
public class SimpleNodeModificationTOImpl<T> extends SimpleNodeTOImpl<T> {
private static final long serialVersionUID = 1L;
* @param value
* @param modifyAction
*/
- public SimpleNodeModificationTOImpl(QName qname, CompositeNode parent,
- T value, ModifyAction modifyAction) {
+ public SimpleNodeModificationTOImpl(final QName qname, final CompositeNode parent,
+ final T value, final ModifyAction modifyAction) {
super(qname, parent, value);
setModificationAction(modifyAction);
}
*/
package org.opendaylight.yangtools.yang.data.impl;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
import org.opendaylight.yangtools.yang.data.api.ModifyAction;
import org.opendaylight.yangtools.yang.data.api.MutableSimpleNode;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
-
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.io.Serializable;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
/**
* @author michal.rehak
* @param <T> type of simple node value
*
+ * @deprecated Use one of the {@link NormalizedNode} implementation packages.
*/
-public class SimpleNodeTOImpl<T> extends AbstractNodeTO<T> implements
- SimpleNode<T>, Serializable {
+@Deprecated
+public class SimpleNodeTOImpl<T> extends AbstractNodeTO<T> implements SimpleNode<T>, Serializable {
private static final long serialVersionUID = 100L;
* @param parent
* @param value
*/
- public SimpleNodeTOImpl(QName qname, CompositeNode parent, T value) {
+ public SimpleNodeTOImpl(final QName qname, final CompositeNode parent, final T value) {
super(qname, parent, value);
}
* @param value
* @param modifyAction
*/
- public SimpleNodeTOImpl(QName qname, CompositeNode parent, T value, ModifyAction modifyAction) {
+ public SimpleNodeTOImpl(final QName qname, final CompositeNode parent, final T value, final ModifyAction modifyAction) {
super(qname, parent, value, modifyAction);
}
return super.toString() + ", value = "+getValue();
}
- // Serialization related
+ // Serialization related
- private void readObject(ObjectInputStream aStream) throws IOException, ClassNotFoundException {
+ private void readObject(final ObjectInputStream aStream) throws IOException, ClassNotFoundException {
aStream.defaultReadObject();
QName qName = (QName)aStream.readObject();
CompositeNode parent = (CompositeNode) aStream.readObject();
init(qName, parent, value, modifyAction);
}
- private void writeObject(ObjectOutputStream aStream) throws IOException {
+ private void writeObject(final ObjectOutputStream aStream) throws IOException {
aStream.defaultWriteObject();
//manually serialize superclass
aStream.writeObject(getQName());
*/
package org.opendaylight.yangtools.yang.data.impl.util;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.collect.Iterables;
+
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
-import com.google.common.collect.Iterables;
-
-import static com.google.common.base.Preconditions.*;
-
-public abstract class AbstractCompositeNodeBuilder<P extends CompositeNode> //
- extends AbstractNodeBuilder<P, CompositeNodeBuilder<P>> //
- implements CompositeNodeBuilder<P> {
+/**
+ * @deprecated Use one of the {@link NormalizedNodeContainerBuilder} implementations.
+ */
+@Deprecated
+public abstract class AbstractCompositeNodeBuilder<P extends CompositeNode> extends AbstractNodeBuilder<P, CompositeNodeBuilder<P>> implements CompositeNodeBuilder<P> {
final List<Node<?>> childNodes;
childNodes = new ArrayList<>();
}
- public AbstractCompositeNodeBuilder(QName nodeType, Map<QName, String> attributes) {
+ public AbstractCompositeNodeBuilder(final QName nodeType, final Map<QName, String> attributes) {
super(nodeType, attributes);
childNodes = new ArrayList<>();
}
- public AbstractCompositeNodeBuilder(QName nodeType, Iterable<? extends Node<?>> nodes) {
+ public AbstractCompositeNodeBuilder(final QName nodeType, final Iterable<? extends Node<?>> nodes) {
super(nodeType);
childNodes = new ArrayList<>();
}
@Override
- public AbstractCompositeNodeBuilder<P> add(Node<?> node) {
+ public AbstractCompositeNodeBuilder<P> add(final Node<?> node) {
childNodes.add(checkNotNull(node, "Node should not be null"));
return this;
}
@Override
- public AbstractCompositeNodeBuilder<P> addAll(Iterable<? extends Node<?>> nodes) {
+ public AbstractCompositeNodeBuilder<P> addAll(final Iterable<? extends Node<?>> nodes) {
Iterables.addAll(childNodes, checkNotNull(nodes, "Node should not be null"));
return this;
}
@Override
- public CompositeNodeBuilder<P> addLeaf(String leafLocalName, String leafValue) {
+ public CompositeNodeBuilder<P> addLeaf(final String leafLocalName, final String leafValue) {
return addLeaf(QName.create(getQName(), leafLocalName), leafValue);
}
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
import org.opendaylight.yangtools.yang.data.api.Node;
+/*
+ * @deprecated Use one of the NormalizedNode builders instead.
+ */
+@Deprecated
public interface CompositeNodeBuilder<P extends CompositeNode> extends NodeBuilder<P,CompositeNodeBuilder<P>> {
CompositeNodeBuilder<P> addLeaf(QName leafName,Object leafValue);
*/
package org.opendaylight.yangtools.yang.data.impl;
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertNotNull;
+import static junit.framework.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
import org.apache.commons.lang.SerializationUtils;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.ModifyAction;
import org.opendaylight.yangtools.yang.data.api.Node;
-import java.util.ArrayList;
-import java.util.List;
-
-import static junit.framework.Assert.assertEquals;
-import static junit.framework.Assert.assertNotNull;
-import static junit.framework.Assert.assertTrue;
-
+@Deprecated
public class CompositeNodeTOImplTest {
@Test
public void testSerialization() throws Exception{
* @author michal.rehak
*
*/
+@Deprecated
public class LazyNodeToNodeMapTest {
private LazyNodeToNodeMap lazyN2N;
/**
* @author michal.rehak
- *
*/
+@Deprecated
public class MyNodeBuilder extends BuilderSupport {
- private static final Logger LOG = LoggerFactory
- .getLogger(MyNodeBuilder.class);
+ private static final Logger LOG = LoggerFactory.getLogger(MyNodeBuilder.class);
private URI qnNamespace;
private final String qnPrefix;
private CompositeNode rootNode;
- /**
- * @param baseQName
- */
- private MyNodeBuilder(final QName baseQName) {
- qnNamespace = baseQName.getNamespace();
- qnPrefix = baseQName.getPrefix();
- qnRevision = baseQName.getRevision();
+ /**
+ * @param baseQName
+ */
+ private MyNodeBuilder(final QName baseQName) {
+ qnNamespace = baseQName.getNamespace();
+ qnPrefix = baseQName.getPrefix();
+ qnRevision = baseQName.getRevision();
}
- /**
- * @return initialized singleton instance
- */
- public static MyNodeBuilder newInstance() {
- QName qName = null;
- try {
- qName = new QName(
- new URI("urn:opendaylight:controller:network"),
- new Date(42), "yang-data-impl-groovyTest_", "node");
+ /**
+ * @return initialized singleton instance
+ */
+ public static MyNodeBuilder newInstance() {
+ QName qName = null;
+ try {
+ qName = new QName(
+ new URI("urn:opendaylight:controller:network"),
+ new Date(42), "yang-data-impl-groovyTest_", "node");
} catch (URISyntaxException e) {
- LOG.error(e.getMessage(), e);
+ LOG.error(e.getMessage(), e);
}
return new MyNodeBuilder(qName);
}
@Override
protected void setParent(final Object parent, final Object child) {
- // do nothing
+ // do nothing
if (child instanceof AbstractNodeTO<?>) {
((AbstractNodeTO<?>) child).setParent((CompositeNode) parent);
} else {
}
private QName createQName(final Object localName) {
- LOG.debug("qname for: "+localName);
- return new QName(qnNamespace, qnRevision, qnPrefix, (String) localName);
+ LOG.debug("qname for: "+localName);
+ return new QName(qnNamespace, qnRevision, qnPrefix, (String) localName);
}
- protected CompositeNode getCurrentNode() {
- if (getCurrent() != null) {
- if (getCurrent() instanceof CompositeNode) {
- return (CompositeNode) getCurrent();
+ protected CompositeNode getCurrentNode() {
+ if (getCurrent() != null) {
+ if (getCurrent() instanceof CompositeNode) {
+ return (CompositeNode) getCurrent();
- } else {
- throw new IllegalAccessError("current node is not of type CompositeNode, but: "
- +getCurrent().getClass().getSimpleName());
- }
- }
+ } else {
+ throw new IllegalAccessError("current node is not of type CompositeNode, but: "
+ +getCurrent().getClass().getSimpleName());
+ }
+ }
- return null;
+ return null;
}
- @Override
- protected Object postNodeCompletion(final Object parent, final Object node) {
- Node<?> nodeRevisited = (Node<?>) node;
- LOG.debug("postNodeCompletion at: \n "+ nodeRevisited+"\n "+parent);
- if (nodeRevisited instanceof MutableCompositeNode) {
- MutableCompositeNode mutant = (MutableCompositeNode) nodeRevisited;
- if (mutant.getValue().isEmpty()) {
- LOG.error("why is it having empty value? -- " + mutant);
- }
- nodeRevisited = NodeFactory.createImmutableCompositeNode(
- mutant.getNodeType(), mutant.getParent(), mutant.getValue(), mutant.getModificationAction());
- NodeUtils.fixChildrenRelation((CompositeNode) nodeRevisited);
-
- if (parent == null) {
- rootNode = (CompositeNode) nodeRevisited;
- } else {
- NodeUtils.fixParentRelation(nodeRevisited);
- nodeRevisited.getParent().getValue().remove(mutant);
- }
- }
-
-
- return nodeRevisited;
- }
-
- /**
- * @return tree root
- */
- public CompositeNode getRootNode() {
+ @Override
+ protected Object postNodeCompletion(final Object parent, final Object node) {
+ Node<?> nodeRevisited = (Node<?>) node;
+ LOG.debug("postNodeCompletion at: \n "+ nodeRevisited+"\n "+parent);
+ if (nodeRevisited instanceof MutableCompositeNode) {
+ MutableCompositeNode mutant = (MutableCompositeNode) nodeRevisited;
+ if (mutant.getValue().isEmpty()) {
+ LOG.error("why is it having empty value? -- " + mutant);
+ }
+ nodeRevisited = NodeFactory.createImmutableCompositeNode(
+ mutant.getNodeType(), mutant.getParent(), mutant.getValue(), mutant.getModificationAction());
+ NodeUtils.fixChildrenRelation((CompositeNode) nodeRevisited);
+
+ if (parent == null) {
+ rootNode = (CompositeNode) nodeRevisited;
+ } else {
+ NodeUtils.fixParentRelation(nodeRevisited);
+ nodeRevisited.getParent().getValue().remove(mutant);
+ }
+ }
+
+
+ return nodeRevisited;
+ }
+
+ /**
+ * @return tree root
+ */
+ public CompositeNode getRootNode() {
return rootNode;
}
}
\ No newline at end of file
* @author michal.rehak
*
*/
+@Deprecated
public class NodeFactoryTest {
private QName qName;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeUtils;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;
/**
* @author michal.rehak
*
+ * @deprecated Use {@link NormalizedNodeUtils} instead.
*/
+@Deprecated
public abstract class NodeHelper {
private static final Logger LOG = LoggerFactory.getLogger(NodeHelper.class);
* @author michal.rehak
*
*/
+@Deprecated
public class NodeModificationBuilderImplTest {
private static final Logger LOG = LoggerFactory.getLogger(NodeModificationBuilderImplTest.class);
import java.io.IOException;
import java.net.URI;
import java.util.Date;
-import java.util.List;
-import java.util.Map;
import java.util.Deque;
import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
import org.junit.Assert;
import org.junit.Before;
* @author michal.rehak
*
*/
+@Deprecated
public class NodeUtilsTest {
private static final Logger LOG = LoggerFactory
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
+/**
+ * @deprecated Use one of the {@link NormalizedNodeContainer} implementation packages.
+ */
+@Deprecated
public abstract class AbstractContainerNode extends AbstractNode<List<Node<?>>> implements CompositeNode {
@Override
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
import org.opendaylight.yangtools.yang.data.api.ModifyAction;
import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+/**
+ * @deprecated Use one of the {@link NormalizedNode} implementation packages.
+ */
+@Deprecated
public abstract class AbstractNode<T> implements Node<T> {
private final QName nodeName;
private final CompositeNode parent;
- protected AbstractNode(QName name, CompositeNode parent) {
+ protected AbstractNode(final QName name, final CompositeNode parent) {
nodeName = name;
this.parent = parent;
}
+ @Override
public QName getNodeType() {
return this.nodeName;
}
+ @Override
public CompositeNode getParent() {
return parent;
}
import org.opendaylight.yangtools.yang.data.api.MutableSimpleNode;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+/**
+ * @deprecated Use one of the {@link NormalizedNode} implementation packages.
+ */
+@Deprecated
public final class Nodes {
private Nodes() {
}
- public static <T> SimpleNode<T> leafNode(QName name, T value) {
+ public static <T> SimpleNode<T> leafNode(final QName name, final T value) {
return new SimpleNodeTO<T>(name, value, null);
}
- public static CompositeNode containerNode(QName name, List<Node<?>> children) {
+ public static CompositeNode containerNode(final QName name, final List<Node<?>> children) {
return containerNode(name, children, null);
}
- public static CompositeNode containerNode(QName name, List<Node<?>> children, CompositeNode parent) {
+ public static CompositeNode containerNode(final QName name, final List<Node<?>> children, final CompositeNode parent) {
return new ContainerNodeTO(name, parent, nodeMapFromList(children));
}
- public static Map<QName, List<Node<?>>> nodeMapFromList(List<Node<?>> children) {
+ public static Map<QName, List<Node<?>>> nodeMapFromList(final List<Node<?>> children) {
Map<QName, List<Node<?>>> map = new HashMap<QName, List<Node<?>>>();
for (Node<?> node : children) {
return map;
}
+ /**
+ * @deprecated Use one of the {@link NormalizedNode} implementation packages.
+ */
+ @Deprecated
private static class ContainerNodeTO extends AbstractContainerNode {
private final Map<QName, List<Node<?>>> nodeMap;
- public ContainerNodeTO(QName name, Map<QName, List<Node<?>>> nodeMap) {
+ public ContainerNodeTO(final QName name, final Map<QName, List<Node<?>>> nodeMap) {
super(name);
this.nodeMap = nodeMap;
}
- public ContainerNodeTO(QName name, CompositeNode parent, Map<QName, List<Node<?>>> nodeMap) {
+ public ContainerNodeTO(final QName name, final CompositeNode parent, final Map<QName, List<Node<?>>> nodeMap) {
super(name, parent);
this.nodeMap = nodeMap;
}
/*
* (non-Javadoc)
- *
+ *
* @see
* org.opendaylight.yangtools.yang.data.api.CompositeNode#asMutable()
*/
}
@Override
- public List<Node<?>> setValue(List<Node<?>> value) {
+ public List<Node<?>> setValue(final List<Node<?>> value) {
return null;
}
}
@Override
- public boolean containsKey(Object key) {
+ public boolean containsKey(final Object key) {
return nodeMap.containsKey(key);
}
@Override
- public boolean containsValue(Object value) {
+ public boolean containsValue(final Object value) {
return nodeMap.containsValue(value);
}
@Override
- public List<Node<?>> get(Object key) {
+ public List<Node<?>> get(final Object key) {
return nodeMap.get(key);
}
@Override
- public List<Node<?>> put(QName key, List<Node<?>> value) {
+ public List<Node<?>> put(final QName key, final List<Node<?>> value) {
return nodeMap.put(key, value);
}
@Override
- public List<Node<?>> remove(Object key) {
+ public List<Node<?>> remove(final Object key) {
return nodeMap.remove(key);
}
@Override
- public void putAll(Map<? extends QName, ? extends List<Node<?>>> m) {
+ public void putAll(final Map<? extends QName, ? extends List<Node<?>>> m) {
nodeMap.putAll(m);
}
@Override
public Set<java.util.Map.Entry<QName, List<Node<?>>>> entrySet() {
-
+
return nodeMap.entrySet();
}
}
+ /**
+ * @deprecated Use one of the {@link NormalizedNode} implementation packages.
+ */
+ @Deprecated
private static class SimpleNodeTO<T> extends AbstractNode<T> implements SimpleNode<T> {
private final T value;
- protected SimpleNodeTO(QName name, T val, CompositeNode parent) {
+ protected SimpleNodeTO(final QName name, final T val, final CompositeNode parent) {
super(name, parent);
value = val;
/*
* (non-Javadoc)
- *
+ *
* @see org.opendaylight.yangtools.yang.data.api.SimpleNode#asMutable()
*/
@Override
// TODO Auto-generated method stub
return null;
}
-
+
@Override
- public T setValue(T value) {
+ public T setValue(final T value) {
return null;
}
-
+
@Override
public QName getKey() {
return getNodeType();