import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.w3c.dom.Element;
+@Deprecated
final class ElementIdentityrefParser extends AbstractStringIdentityrefCodec {
private final SchemaContext schema;
private final Element element;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
import org.w3c.dom.Element;
+@Deprecated
final class ElementInstanceIdentifierParser extends AbstractStringInstanceIdentifierCodec {
private final SchemaContext schema;
private final Element element;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.w3c.dom.Element;
+/**
+ * @deprecated Use yang-data-codec-xml instead.
+ */
+@Deprecated
public final class InstanceIdentifierForXmlCodec {
private InstanceIdentifierForXmlCodec() {
throw new UnsupportedOperationException("Utility class");
import com.google.common.base.Preconditions;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
-
import java.net.URI;
import java.util.Map;
-
import javax.xml.XMLConstants;
import javax.xml.namespace.NamespaceContext;
+@Deprecated
class RandomPrefix {
// 32 characters, carefully chosen
private static final String LOOKUP = "abcdefghiknoprstABCDEFGHIKNOPRST";
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+@Deprecated
final class RandomPrefixInstanceIdentifierSerializer extends AbstractStringInstanceIdentifierCodec {
private final RandomPrefix prefixes = new RandomPrefix();
private final DataSchemaContextTree schemaTree;
-
- RandomPrefixInstanceIdentifierSerializer(SchemaContext ctx) {
+ RandomPrefixInstanceIdentifierSerializer(final SchemaContext ctx) {
schemaTree = DataSchemaContextTree.from(ctx);
}
protected DataSchemaContextTree getDataContextTree() {
return schemaTree;
}
-
}
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+@Deprecated
final class SchemaAwareXMLStreamNormalizedNodeStreamWriter extends XMLStreamNormalizedNodeStreamWriter<SchemaNode> {
private final SchemaTracker tracker;
private final XmlStreamUtils streamUtils;
}
@Override
- public void leafNode(NodeIdentifier name, Object value, Map<QName, String> attributes) throws IOException {
+ public void leafNode(final NodeIdentifier name, final Object value, final Map<QName, String> attributes)
+ throws IOException {
final LeafSchemaNode schema = tracker.leafNode(name);
writeElement(schema.getQName(), value, attributes, schema);
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
+@Deprecated
class SchemalessXMLStreamNormalizedNodeStreamWriter extends XMLStreamNormalizedNodeStreamWriter<Object> {
private enum ContainerType {
CONTAINER,
private final Deque<ContainerType> containerTypeStack = new ArrayDeque<>();
- private SchemalessXMLStreamNormalizedNodeStreamWriter(XMLStreamWriter writer) {
+ private SchemalessXMLStreamNormalizedNodeStreamWriter(final XMLStreamWriter writer) {
super(writer);
}
- static NormalizedNodeStreamWriter newInstance(XMLStreamWriter writer) {
+ static NormalizedNodeStreamWriter newInstance(final XMLStreamWriter writer) {
return new SchemalessXMLStreamNormalizedNodeStreamWriter(writer);
}
@Override
- public void leafNode(NodeIdentifier name, Object value, Map<QName, String> attributes) throws IOException {
+ public void leafNode(final NodeIdentifier name, final Object value, final Map<QName, String> attributes)
+ throws IOException {
writeElement(name.getNodeType(), value, attributes, null);
}
@Override
- public void leafSetEntryNode(QName name, Object value, Map<QName, String> attributes) throws IOException {
+ public void leafSetEntryNode(final QName name, final Object value, final Map<QName, String> attributes)
+ throws IOException {
writeElement(name, value, attributes, null);
}
@Override
- public void leafNode(NodeIdentifier name, Object value) throws IOException {
+ public void leafNode(final NodeIdentifier name, final Object value) throws IOException {
writeElement(name.getNodeType(), value, Collections.emptyMap(), null);
}
@Override
- public void leafSetEntryNode(QName name, Object value) throws IOException {
+ public void leafSetEntryNode(final QName name, final Object value) throws IOException {
writeElement(name, value, Collections.emptyMap(), null);
}
@Override
- public void startLeafSet(NodeIdentifier name, int childSizeHint) throws IOException {
+ public void startLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException {
containerTypeStack.push(ContainerType.LEAF_SET);
}
@Override
- public void startOrderedLeafSet(NodeIdentifier name, int childSizeHint)
+ public void startOrderedLeafSet(final NodeIdentifier name, final int childSizeHint)
throws IOException, IllegalArgumentException {
containerTypeStack.push(ContainerType.LEAF_SET);
}
@Override
- public void startContainerNode(NodeIdentifier name, int childSizeHint) throws IOException {
+ public void startContainerNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
containerTypeStack.push(ContainerType.CONTAINER);
startElement(name.getNodeType());
}
@Override
- public void startChoiceNode(NodeIdentifier name, int childSizeHint) throws IOException {
+ public void startChoiceNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
containerTypeStack.push(ContainerType.CHOICE);
}
@Override
- public void startAugmentationNode(AugmentationIdentifier identifier) throws IOException {
+ public void startAugmentationNode(final AugmentationIdentifier identifier) throws IOException {
containerTypeStack.push(ContainerType.AUGMENTATION);
}
@Override
- public void anyxmlNode(NodeIdentifier name, Object value) throws IOException {
+ public void anyxmlNode(final NodeIdentifier name, final Object value) throws IOException {
anyxmlNode(name.getNodeType(), value);
}
@Override
- public void startYangModeledAnyXmlNode(NodeIdentifier name, int childSizeHint) throws IOException {
+ public void startYangModeledAnyXmlNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
containerTypeStack.push(ContainerType.ANY_XML);
startElement(name.getNodeType());
}
@Override
- protected void writeValue(XMLStreamWriter xmlWriter, QName qname, @Nonnull Object value, Object context)
- throws XMLStreamException {
+ protected void writeValue(final XMLStreamWriter xmlWriter, final QName qname, @Nonnull final Object value,
+ final Object context) throws XMLStreamException {
xmlWriter.writeCharacters(value.toString());
}
@Override
- protected void startList(NodeIdentifier name) {
+ protected void startList(final NodeIdentifier name) {
containerTypeStack.push(ContainerType.LIST);
}
@Override
- protected void startListItem(PathArgument name) throws IOException {
+ protected void startListItem(final PathArgument name) throws IOException {
containerTypeStack.push(ContainerType.LIST_ITEM);
startElement(name.getNodeType());
}
@Override
- protected void endNode(XMLStreamWriter xmlWriter) throws IOException, XMLStreamException {
+ protected void endNode(final XMLStreamWriter xmlWriter) throws IOException, XMLStreamException {
ContainerType type = containerTypeStack.pop();
switch(type) {
case CONTAINER:
* SchemaContext and encodes values appropriately according to the yang schema. The other is
* schema-less and merely outputs values using toString. The latter is intended for debugging
* where doesn't have a SchemaContext available and isn't meant for production use.
+ *
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class XMLStreamNormalizedNodeStreamWriter<T> implements NormalizedNodeStreamAttributeWriter {
private static final Logger LOG = LoggerFactory.getLogger(XMLStreamNormalizedNodeStreamWriter.class);
private static final String COM_SUN_TRANSFORMER = "com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl";
import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+/**
+ * @deprecated Use yang-data-codec-xml instead.
+ */
+@Deprecated
public interface XmlCodecProvider {
TypeDefinitionAwareCodec<Object, ? extends TypeDefinition<?>> codecFor(TypeDefinition<?> baseType);
import org.w3c.dom.Document;
import org.w3c.dom.Element;
+/**
+ * @deprecated Use yang-data-codec-xml instead.
+ */
+@Deprecated
public final class XmlDocumentUtils {
public static final QName OPERATION_ATTRIBUTE_QNAME = QName.create(SchemaContext.NAME, "operation");
/**
* Utility class for bridging JAXP Stream and YANG Data APIs. Note that the definition of this class
* by no means final and subject to change as more functionality is centralized here.
+ *
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
@Beta
public final class XmlStreamUtils {
private static final Logger LOG = LoggerFactory.getLogger(XmlStreamUtils.class);
/**
* Common XML-related utility methods, which are not specific to a particular
* JAXP API.
+ *
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public final class XmlUtils {
public static final XmlCodecProvider DEFAULT_XML_CODEC_PROVIDER =
TypeDefinitionAwareCodec::from;
* type of NormalizedNode to be serialized
* @param <S>
* schema belonging to the type N of NormalizedNode
+ *
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public interface FromNormalizedNodeSerializer<E, N extends NormalizedNode<?, ?>, S> {
/**
*
* @param <E>
* type of resulting/serialized element from NormalizedNode
+ *
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public interface FromNormalizedNodeSerializerFactory<E> {
FromNormalizedNodeSerializer<E, AugmentationNode, AugmentationSchema> getAugmentationNodeSerializer();
FromNormalizedNodeSerializer<E, ChoiceNode, ChoiceSchemaNode> getChoiceNodeSerializer();
* type of NormalizedNode to be the result of parsing
* @param <S>
* schema belonging to the type N of NormalizedNode
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public interface ToNormalizedNodeParser<E, N extends NormalizedNode<?, ?>, S> {
/**
*
* @param <E>
* type of element to be parsed into NormalizedNode
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public interface ToNormalizedNodeParserFactory<E> {
ToNormalizedNodeParser<E, AugmentationNode, AugmentationSchema> getAugmentationNodeParser();
ToNormalizedNodeParser<E, ChoiceNode, ChoiceSchemaNode> getChoiceNodeParser();
* Abstract(base) parser for LeafNodes, parses elements of type E.
*
* @param <E> type of elements to be parsed
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class AnyXmlNodeBaseParser<E> implements
ToNormalizedNodeParser<E, AnyXmlNode, AnyXmlSchemaNode> {
@Override
- public final AnyXmlNode parse(Iterable<E> elements, AnyXmlSchemaNode schema) {
+ public final AnyXmlNode parse(final Iterable<E> elements, final AnyXmlSchemaNode schema) {
final int size = Iterables.size(elements);
Preconditions.checkArgument(size == 1, "Elements mapped to any-xml node illegal count: %s", size);
* Abstract(base) parser for AugmentationNode, parses elements of type E.
*
* @param <E> type of elements to be parsed
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class AugmentationNodeBaseParser<E> extends
BaseDispatcherParser<E, YangInstanceIdentifier.AugmentationIdentifier, AugmentationNode, AugmentationSchema> {
/**
* Abstract(base) Parser for DataContainerNodes e.g. ContainerNode, AugmentationNode.
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class BaseDispatcherParser<E, P extends YangInstanceIdentifier.PathArgument, N extends DataContainerNode<P>, S>
implements ExtensibleParser<P, E, N, S> {
* Abstract(base) parser for ChoiceNodes, parses elements of type E.
*
* @param <E> type of elements to be parsed
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class ChoiceNodeBaseParser<E> extends BaseDispatcherParser<E, YangInstanceIdentifier.NodeIdentifier, ChoiceNode, ChoiceSchemaNode> {
protected ChoiceNodeBaseParser() {}
* Abstract(base) parser for ContainerNodes, parses elements of type E.
*
* @param <E> type of elements to be parsed
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class ContainerNodeBaseParser<E> extends
BaseDispatcherParser<E, YangInstanceIdentifier.NodeIdentifier, ContainerNode, ContainerSchemaNode> {
* @param <E> type of element to be parsed into NormalizedNode
* @param <N> type of NormalizedNode to be the result of parsing
* @param <S> schema belonging to the type N of NormalizedNode
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public interface ExtensibleParser<P extends YangInstanceIdentifier.PathArgument, E, N extends NormalizedNode<P, ?>, S>
extends ToNormalizedNodeParser<E, N, S> {
* Abstract(base) parser for LeafNodes, parses elements of type E.
*
* @param <E> type of elements to be parsed
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class LeafNodeBaseParser<E> implements ExtensibleParser<NodeIdentifier, E, LeafNode<?>, LeafSchemaNode> {
private final BuildingStrategy<NodeIdentifier, LeafNode<?>> buildingStrategy;
* Abstract(base) parser for LeafSetEntryNodes, parses elements of type E.
*
* @param <E> type of elements to be parsed
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class LeafSetEntryNodeBaseParser<E> implements ExtensibleParser<NodeWithValue, E, LeafSetEntryNode<?>, LeafListSchemaNode> {
private final BuildingStrategy<NodeWithValue, LeafSetEntryNode<?>> buildingStrategy;
* Abstract(base) parser for LeafSetNodes, parses elements of type E.
*
* @param <E> type of elements to be parsed
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class LeafSetNodeBaseParser<E> implements
ToNormalizedNodeParser<E, LeafSetNode<?>, LeafListSchemaNode> {
@Override
- public final LeafSetNode<?> parse(Iterable<E> childNodes, LeafListSchemaNode schema) {
+ public final LeafSetNode<?> parse(final Iterable<E> childNodes, final LeafListSchemaNode schema) {
ListNodeBuilder<Object, LeafSetEntryNode<Object>> leafListBuilder =
- (schema.isUserOrdered() ? Builders.orderedLeafSetBuilder(schema) : Builders.leafSetBuilder(schema));
+ schema.isUserOrdered() ? Builders.orderedLeafSetBuilder(schema) : Builders.leafSetBuilder(schema);
for (E childNode : childNodes) {
LeafSetEntryNode<?> builtChild = getLeafSetEntryNodeParser().parse(
Collections.singletonList(childNode), schema);
*
* @param <E>
* type of elements to be parsed
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class ListEntryNodeBaseParser<P extends YangInstanceIdentifier.PathArgument, E, N extends DataContainerNode<P>> extends
BaseDispatcherParser<E, P, N, ListSchemaNode> {
*
* @param <E>
* type of elements to be parsed
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class ListNodeBaseParser<E, N extends NormalizedNode<?, ?>, O extends NormalizedNode<YangInstanceIdentifier.NodeIdentifier, ?>, S extends ListSchemaNode>
implements ExtensibleParser<YangInstanceIdentifier.NodeIdentifier, E, O, S> {
}
@Override
- public O parse(Iterable<E> childNodes, S schema) {
+ public O parse(final Iterable<E> childNodes, final S schema) {
CollectionNodeBuilder<N, O> listBuilder = provideBuilder(schema);
buildingStrategy.prepareAttributes(Collections.emptyMap(), listBuilder);
*
* @param <E>
* type of elements to be parsed
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class MapNodeBaseParser<E> extends ListNodeBaseParser<E, MapEntryNode, MapNode, ListSchemaNode> {
public MapNodeBaseParser() {
super(buildingStrategy);
}
- protected CollectionNodeBuilder<MapEntryNode, MapNode> provideBuilder(ListSchemaNode schema) {
+ @Override
+ protected CollectionNodeBuilder<MapEntryNode, MapNode> provideBuilder(final ListSchemaNode schema) {
return Builders.mapBuilder(schema);
}
* Dispatches the parsing process of elements according to schema and returns the parsed Node.
*
* @param <E> type of elements parsed
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public interface NodeParserDispatcher<E> {
DataContainerChild<?, ?> dispatchChildElement(Object schema, List<E> childNodes);
*
* @param <E>
* type of elements to be parsed
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class OrderedListNodeBaseParser<E> extends
ListNodeBaseParser<E, MapEntryNode, OrderedMapNode, ListSchemaNode> {
}
@Override
- protected CollectionNodeBuilder<MapEntryNode, OrderedMapNode> provideBuilder(ListSchemaNode schema) {
+ protected CollectionNodeBuilder<MapEntryNode, OrderedMapNode> provideBuilder(final ListSchemaNode schema) {
return Builders.orderedMapBuilder(schema);
}
*
* @param <E>
* type of elements to be parsed
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class UnkeyedListNodeBaseParser<E> extends
ListNodeBaseParser<E, UnkeyedListEntryNode, UnkeyedListNode, ListSchemaNode> {
*
* @param <E>
* type of elements to be parsed
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class YangModeledAnyXmlNodeBaseParser<E> implements
ToNormalizedNodeParser<E, YangModeledAnyXmlNode, YangModeledAnyXmlSchemaNode> {
@Override
- public final YangModeledAnyXmlNode parse(Iterable<E> elements, YangModeledAnyXmlSchemaNode schema) {
+ public final YangModeledAnyXmlNode parse(final Iterable<E> elements, final YangModeledAnyXmlSchemaNode schema) {
final int size = Iterables.size(elements);
Preconditions.checkArgument(size == 1, "Elements mapped to yang modeled any-xml node illegal count: %s", size);
* Abstract(base) serializer for AnyXmlNodes, serializes elements of type E.
*
* @param <E> type of serialized elements
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class AnyXmlNodeBaseSerializer<E> implements
FromNormalizedNodeSerializer<E, AnyXmlNode, AnyXmlSchemaNode> {
@Override
- public final Iterable<E> serialize(AnyXmlSchemaNode schema, AnyXmlNode node) {
+ public final Iterable<E> serialize(final AnyXmlSchemaNode schema, final AnyXmlNode node) {
return Collections.singletonList(serializeAnyXml(node));
}
package org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer;
import java.util.Set;
-
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
* Abstract(base) serializer for AugmentationNode, serializes elements of type E.
*
* @param <E> type of serialized elements
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class AugmentationNodeBaseSerializer<E> extends
BaseDispatcherSerializer<E, AugmentationNode, AugmentationSchema> {
@Override
- protected Set<DataSchemaNode> getRealSchemasForAugment(AugmentationSchema schema, AugmentationSchema augmentationSchema) {
+ protected Set<DataSchemaNode> getRealSchemasForAugment(final AugmentationSchema schema, final AugmentationSchema augmentationSchema) {
return SchemaUtils.getRealSchemasForAugment(schema, augmentationSchema);
}
@Override
- protected DataSchemaNode getSchemaForChild(AugmentationSchema schema,
- DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> childNode) {
+ protected DataSchemaNode getSchemaForChild(final AugmentationSchema schema,
+ final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> childNode) {
return SchemaUtils.findSchemaForChild(schema, childNode.getNodeType());
}
@Override
- protected AugmentationSchema getAugmentedCase(AugmentationSchema schema, AugmentationNode augmentationNode) {
+ protected AugmentationSchema getAugmentedCase(final AugmentationSchema schema, final AugmentationNode augmentationNode) {
throw new UnsupportedOperationException("");
}
/**
* Abstract(base) Serializer for DataContainerNodes e.g. ContainerNode, AugmentationNode.
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class BaseDispatcherSerializer<E, N extends DataContainerNode<?>, S> implements
FromNormalizedNodeSerializer<E, N, S> {
protected abstract NodeSerializerDispatcher<E> getNodeDispatcher();
@Override
- public Iterable<E> serialize(S schema, N node) {
+ public Iterable<E> serialize(final S schema, final N node) {
List<Iterable<E>> choiceChildren = Lists.newArrayList();
for (DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> choiceChild : node.getValue()) {
* Abstract(base) serializer for ChoiceNodes, serializes elements of type E.
*
* @param <E> type of serialized elements
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class ChoiceNodeBaseSerializer<E> extends BaseDispatcherSerializer<E, ChoiceNode, ChoiceSchemaNode> {
@Override
package org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer;
import java.util.Set;
-
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
* Abstract(base) serializer for ContainerNodes, serializes elements of type E.
*
* @param <E> type of serialized elements
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class ContainerNodeBaseSerializer<E> extends
BaseDispatcherSerializer<E, ContainerNode, ContainerSchemaNode> {
@Override
- protected final DataSchemaNode getSchemaForChild(ContainerSchemaNode schema,
- DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> childNode) {
+ protected final DataSchemaNode getSchemaForChild(final ContainerSchemaNode schema,
+ final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> childNode) {
return SchemaUtils.findSchemaForChild(schema, childNode.getNodeType());
}
@Override
- protected final AugmentationSchema getAugmentedCase(ContainerSchemaNode schema, AugmentationNode augmentationNode) {
+ protected final AugmentationSchema getAugmentedCase(final ContainerSchemaNode schema, final AugmentationNode augmentationNode) {
return SchemaUtils.findSchemaForAugment(schema, augmentationNode.getIdentifier().getPossibleChildNames());
}
@Override
- protected final Set<DataSchemaNode> getRealSchemasForAugment(ContainerSchemaNode schema, AugmentationSchema augmentationSchema) {
+ protected final Set<DataSchemaNode> getRealSchemasForAugment(final ContainerSchemaNode schema, final AugmentationSchema augmentationSchema) {
return SchemaUtils.getRealSchemasForAugment((AugmentationTarget) schema, augmentationSchema);
}
}
package org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer;
import java.util.Collections;
-
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.FromNormalizedNodeSerializer;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
* Abstract(base) serializer for LeafNodes, serializes elements of type E.
*
* @param <E> type of serialized elements
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class LeafNodeBaseSerializer<E> implements
FromNormalizedNodeSerializer<E, LeafNode<?>, LeafSchemaNode> {
@Override
- public final Iterable<E> serialize(LeafSchemaNode schema, LeafNode<?> node) {
+ public final Iterable<E> serialize(final LeafSchemaNode schema, final LeafNode<?> node) {
return Collections.singletonList(serializeLeaf(schema, node));
}
package org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer;
import java.util.Collections;
-
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.FromNormalizedNodeSerializer;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
* Abstract(base) serializer for LeafSetEntryNodes, serializes elements of type E.
*
* @param <E> type of serialized elements
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class LeafSetEntryNodeBaseSerializer<E> implements
FromNormalizedNodeSerializer<E, LeafSetEntryNode<?>, LeafListSchemaNode> {
@Override
- public final Iterable<E> serialize(LeafListSchemaNode schema, LeafSetEntryNode<?> node) {
+ public final Iterable<E> serialize(final LeafListSchemaNode schema, final LeafSetEntryNode<?> node) {
return Collections.singletonList(serializeLeaf(schema, node));
}
* Abstract(base) serializer for LeafSetNodes, serializes elements of type E.
*
* @param <E> type of serialized elements
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class LeafSetNodeBaseSerializer<E> implements
FromNormalizedNodeSerializer<E, LeafSetNode<?>, LeafListSchemaNode> {
*
* @param <E>
* type of serialized elements
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class ListEntryNodeBaseSerializer<E, N extends DataContainerNode<?>> extends
BaseDispatcherSerializer<E, N, ListSchemaNode> {
@Override
- protected final DataSchemaNode getSchemaForChild(ListSchemaNode schema,
- DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> childNode) {
+ protected final DataSchemaNode getSchemaForChild(final ListSchemaNode schema,
+ final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> childNode) {
return SchemaUtils.findSchemaForChild(schema, childNode.getNodeType());
}
@Override
- protected final AugmentationSchema getAugmentedCase(ListSchemaNode schema, AugmentationNode augmentationNode) {
+ protected final AugmentationSchema getAugmentedCase(final ListSchemaNode schema, final AugmentationNode augmentationNode) {
return SchemaUtils.findSchemaForAugment(schema, augmentationNode.getIdentifier().getPossibleChildNames());
}
@Override
- protected final Set<DataSchemaNode> getRealSchemasForAugment(ListSchemaNode schema,
- AugmentationSchema augmentationSchema) {
+ protected final Set<DataSchemaNode> getRealSchemasForAugment(final ListSchemaNode schema,
+ final AugmentationSchema augmentationSchema) {
return SchemaUtils.getRealSchemasForAugment((AugmentationTarget) schema, augmentationSchema);
}
* containing node type
* @param <O>
* entry node type which is inside containing (N) type
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public abstract class ListNodeBaseSerializer<E, N extends DataContainerChild<NodeIdentifier, Collection<O>>, O extends DataContainerNode<?>>
implements FromNormalizedNodeSerializer<E, N, ListSchemaNode> {
*
* @param <E>
* type of serialized elements
+ * @deprecated Use yang-data-codec-xml instead.
*/
+@Deprecated
public interface NodeSerializerDispatcher<E> {
Iterable<E> dispatchChildElement(Object childSchema,
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
+/**
+ * @deprecated Use yang-data-codec-xml instead.
+ */
+@Deprecated
public final class DomUtils {
private DomUtils() {
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.w3c.dom.Element;
+/**
+ * @deprecated Use yang-data-codec-xml instead.
+ */
+@Deprecated
public class AnyXmlDomParser extends AnyXmlNodeBaseParser<Element> {
@Override
import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils;
import org.w3c.dom.Element;
+@Deprecated
final class AugmentationNodeDomParser extends AugmentationNodeBaseParser<Element> {
private final NodeParserDispatcher<Element> dispatcher;
}
@Override
- protected LinkedListMultimap<QName, Element> mapChildElements(Iterable<Element> elements) {
+ protected LinkedListMultimap<QName, Element> mapChildElements(final Iterable<Element> elements) {
return DomUtils.mapChildElements(elements);
}
import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils;
import org.w3c.dom.Element;
+@Deprecated
final class ChoiceNodeDomParser extends ChoiceNodeBaseParser<Element> {
private final NodeParserDispatcher<Element> dispatcher;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils;
import org.w3c.dom.Element;
+@Deprecated
final class ContainerNodeDomParser extends ContainerNodeBaseParser<Element> {
private final NodeParserDispatcher<Element> dispatcher;
}
@Override
- protected Map<QName, String> getAttributes(Element element) {
+ protected Map<QName, String> getAttributes(final Element element) {
return DomUtils.toAttributes(element.getAttributes());
}
}
@Override
- protected LinkedListMultimap<QName, Element> mapChildElements(Iterable<Element> elements) {
+ protected LinkedListMultimap<QName, Element> mapChildElements(final Iterable<Element> elements) {
return DomUtils.mapChildElementsForSingletonNode(elements.iterator().next());
}
import org.opendaylight.yangtools.yang.model.api.YangModeledAnyXmlSchemaNode;
import org.w3c.dom.Element;
+/**
+ * @deprecated Use yang-data-codec-xml instead.
+ */
+@Deprecated
public final class DomToNormalizedNodeParserFactory implements ToNormalizedNodeParserFactory<Element> {
private final AugmentationNodeDomParser augmentationNodeParser;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.w3c.dom.Element;
+@Deprecated
final class LeafNodeDomParser extends LeafNodeBaseParser<Element> {
private final XmlCodecProvider codecProvider;
private final SchemaContext ctx;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.w3c.dom.Element;
+@Deprecated
final class LeafSetEntryNodeDomParser extends LeafSetEntryNodeBaseParser<Element> {
private final XmlCodecProvider codecProvider;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.w3c.dom.Element;
+@Deprecated
final class LeafSetNodeDomParser extends LeafSetNodeBaseParser<Element> {
private final LeafSetEntryNodeDomParser leafSetEntryNodeBaseParser;
- LeafSetNodeDomParser(LeafSetEntryNodeDomParser leafSetEntryNodeBaseParser) {
+ LeafSetNodeDomParser(final LeafSetEntryNodeDomParser leafSetEntryNodeBaseParser) {
this.leafSetEntryNodeBaseParser = leafSetEntryNodeBaseParser;
}
import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils;
import org.w3c.dom.Element;
+@Deprecated
abstract class ListEntryNodeDomParser<P extends YangInstanceIdentifier.PathArgument, N extends DataContainerNode<P>> extends ListEntryNodeBaseParser<P, Element, N> {
private final NodeParserDispatcher<Element> dispatcher;
}
@Override
- protected LinkedListMultimap<QName, Element> mapChildElements(Iterable<Element> elements) {
+ protected LinkedListMultimap<QName, Element> mapChildElements(final Iterable<Element> elements) {
return DomUtils.mapChildElementsForSingletonNode(elements.iterator().next());
}
}
@Override
- protected Map<QName, String> getAttributes(Element element) {
+ protected Map<QName, String> getAttributes(final Element element) {
return DomUtils.toAttributes(element.getAttributes());
}
}
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.w3c.dom.Element;
+@Deprecated
final class MapEntryNodeDomParser extends ListEntryNodeDomParser<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> {
private final boolean strictParsing;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.w3c.dom.Element;
+@Deprecated
final class MapNodeDomParser extends MapNodeBaseParser<Element> {
private final MapEntryNodeDomParser mapEntryParser;
this.mapEntryParser = mapEntryParser;
}
- MapNodeDomParser(MapEntryNodeDomParser mapEntryParser, final BuildingStrategy<YangInstanceIdentifier.NodeIdentifier, MapNode> strategy) {
+ MapNodeDomParser(final MapEntryNodeDomParser mapEntryParser, final BuildingStrategy<YangInstanceIdentifier.NodeIdentifier, MapNode> strategy) {
super(strategy);
this.mapEntryParser = mapEntryParser;
}
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.w3c.dom.Element;
+@Deprecated
final class OrderedListNodeDomParser extends OrderedListNodeBaseParser<Element> {
private final MapEntryNodeDomParser mapEntryNodeParser;
this.mapEntryNodeParser = mapEntryNodeParser;
}
- OrderedListNodeDomParser(MapEntryNodeDomParser mapEntryNodeParser, final BuildingStrategy<YangInstanceIdentifier.NodeIdentifier, OrderedMapNode> strategy) {
+ OrderedListNodeDomParser(final MapEntryNodeDomParser mapEntryNodeParser, final BuildingStrategy<YangInstanceIdentifier.NodeIdentifier, OrderedMapNode> strategy) {
super(strategy);
this.mapEntryNodeParser = mapEntryNodeParser;
}
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.w3c.dom.Element;
+@Deprecated
final class UnkeyedListEntryNodeDomParser extends ListEntryNodeDomParser<YangInstanceIdentifier.NodeIdentifier, UnkeyedListEntryNode> {
private final boolean strictParsing;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.w3c.dom.Element;
+@Deprecated
final class UnkeyedListNodeDomParser extends UnkeyedListNodeBaseParser<Element> {
private final UnkeyedListEntryNodeDomParser unkeyedListEntryNodeParser;
- UnkeyedListNodeDomParser(UnkeyedListEntryNodeDomParser unkeyedListEntryNodeParser) {
+ UnkeyedListNodeDomParser(final UnkeyedListEntryNodeDomParser unkeyedListEntryNodeParser) {
this.unkeyedListEntryNodeParser = unkeyedListEntryNodeParser;
}
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
+/**
+ * @deprecated Use yang-data-codec-xml instead.
+ */
+@Deprecated
public class YangModeledAnyXmlDomParser extends YangModeledAnyXmlNodeBaseParser<Element> {
private final NodeParserDispatcher<Element> dispatcher;
*/
package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.serializer;
+import com.google.common.base.Preconditions;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.AugmentationNodeBaseSerializer;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.NodeSerializerDispatcher;
import org.w3c.dom.Element;
-import com.google.common.base.Preconditions;
-
+@Deprecated
final class AugmentationNodeDomSerializer extends
AugmentationNodeBaseSerializer<Element> {
private final NodeSerializerDispatcher<Element> dispatcher;
- AugmentationNodeDomSerializer(NodeSerializerDispatcher<Element> dispatcher) {
+ AugmentationNodeDomSerializer(final NodeSerializerDispatcher<Element> dispatcher) {
this.dispatcher = Preconditions.checkNotNull(dispatcher);
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.serializer;
+import com.google.common.base.Preconditions;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.ChoiceNodeBaseSerializer;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.NodeSerializerDispatcher;
import org.w3c.dom.Element;
-import com.google.common.base.Preconditions;
-
+@Deprecated
final class ChoiceNodeDomSerializer extends ChoiceNodeBaseSerializer<Element> {
private final NodeSerializerDispatcher<Element> dispatcher;
*/
package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.serializer;
+import com.google.common.base.Preconditions;
import java.util.Collections;
-
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlDocumentUtils;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.ContainerNodeBaseSerializer;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-import com.google.common.base.Preconditions;
-
-final class ContainerNodeDomSerializer extends
- ContainerNodeBaseSerializer<Element> {
+@Deprecated
+final class ContainerNodeDomSerializer extends ContainerNodeBaseSerializer<Element> {
private final NodeSerializerDispatcher<Element> dispatcher;
private final Document doc;
}
@Override
- public Iterable<Element> serialize(ContainerSchemaNode schema, ContainerNode containerNode) {
+ public Iterable<Element> serialize(final ContainerSchemaNode schema, final ContainerNode containerNode) {
Element itemEl = XmlDocumentUtils.createElementFor(doc, containerNode);
for (Element element : super.serialize(schema, containerNode)) {
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-// TODO Is this used anywhere ? it is replaced by the NormalizedNode stream writer, COuld this be removed ?
-
+/**
+ * @deprecated Use yang-data-codec-xml instead.
+ */
+@Deprecated
public final class DomFromNormalizedNodeSerializerFactory implements FromNormalizedNodeSerializerFactory<Element> {
private final ContainerNodeDomSerializer containerSerializer;
private final ChoiceNodeDomSerializer choiceSerializer;
*/
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.w3c.dom.Document;
import org.w3c.dom.Element;
-import com.google.common.base.Preconditions;
-
+@Deprecated
final class LeafNodeDomSerializer extends LeafNodeBaseSerializer<Element> {
private final XmlCodecProvider codecProvider;
private final Document doc;
- LeafNodeDomSerializer(Document doc, XmlCodecProvider codecProvider) {
+ LeafNodeDomSerializer(final Document doc, final XmlCodecProvider codecProvider) {
this.doc = Preconditions.checkNotNull(doc);
this.codecProvider = Preconditions.checkNotNull(codecProvider);
}
@Override
- protected Element serializeLeaf(LeafSchemaNode schema, LeafNode<?> node) {
+ protected Element serializeLeaf(final LeafSchemaNode schema, final LeafNode<?> node) {
Element itemEl = XmlDocumentUtils.createElementFor(doc, node);
DomUtils.serializeXmlValue(itemEl, schema.getType(), codecProvider, node.getValue());
*/
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.w3c.dom.Document;
import org.w3c.dom.Element;
-import com.google.common.base.Preconditions;
-
-final class LeafSetEntryNodeDomSerializer extends
- LeafSetEntryNodeBaseSerializer<Element> {
+@Deprecated
+final class LeafSetEntryNodeDomSerializer extends LeafSetEntryNodeBaseSerializer<Element> {
private final Document doc;
private final XmlCodecProvider codecProvider;
- LeafSetEntryNodeDomSerializer(Document doc, XmlCodecProvider codecProvider) {
+ LeafSetEntryNodeDomSerializer(final Document doc, final XmlCodecProvider codecProvider) {
this.doc = Preconditions.checkNotNull(doc);
this.codecProvider = Preconditions.checkNotNull(codecProvider);
}
@Override
- protected Element serializeLeaf(LeafListSchemaNode schema, LeafSetEntryNode<?> node) {
+ protected Element serializeLeaf(final LeafListSchemaNode schema, final LeafSetEntryNode<?> node) {
Element itemEl = XmlDocumentUtils.createElementFor(doc, node);
DomUtils.serializeXmlValue(itemEl, schema.getType(), codecProvider, node.getValue());
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.w3c.dom.Element;
+@Deprecated
final class LeafSetNodeDomSerializer extends LeafSetNodeBaseSerializer<Element> {
private final FromNormalizedNodeSerializer<Element, LeafSetEntryNode<?>, LeafListSchemaNode> leafSetEntryNodeSerializer;
- LeafSetNodeDomSerializer(LeafSetEntryNodeDomSerializer leafSetEntryNodeSerializer) {
+ LeafSetNodeDomSerializer(final LeafSetEntryNodeDomSerializer leafSetEntryNodeSerializer) {
this.leafSetEntryNodeSerializer = leafSetEntryNodeSerializer;
}
import org.w3c.dom.Element;
/**
- *
* Common class for list entry node serialization (MapEntry, UnkeyedListEntry nodes)
*
* @param <N>
* concrete entry node type
*/
+@Deprecated
abstract class ListEntryNodeDomSerializer<N extends DataContainerNode<?>> extends
ListEntryNodeBaseSerializer<Element, N> {
private final NodeSerializerDispatcher<Element> dispatcher;
}
@Override
- public Iterable<Element> serialize(ListSchemaNode schema, N node) {
+ public Iterable<Element> serialize(final ListSchemaNode schema, final N node) {
Element itemEl = XmlDocumentUtils.createElementFor(doc, node);
for (Element element : super.serialize(schema, node)) {
import org.w3c.dom.Document;
import org.w3c.dom.Element;
+@Deprecated
final class MapEntryNodeDomSerializer extends ListEntryNodeDomSerializer<MapEntryNode> {
MapEntryNodeDomSerializer(final Document doc, final NodeSerializerDispatcher<Element> dispatcher) {
super(doc, dispatcher);
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.w3c.dom.Element;
+@Deprecated
final class MapNodeDomSerializer extends ListNodeBaseSerializer<Element, MapNode, MapEntryNode> {
private final FromNormalizedNodeSerializer<Element, MapEntryNode, ListSchemaNode> mapEntrySerializer;
- MapNodeDomSerializer(MapEntryNodeDomSerializer mapEntrySerializer) {
+ MapNodeDomSerializer(final MapEntryNodeDomSerializer mapEntrySerializer) {
this.mapEntrySerializer = mapEntrySerializer;
}
import org.w3c.dom.Document;
import org.w3c.dom.Element;
+@Deprecated
final class UnkeyedListEntryNodeDomSerializer extends ListEntryNodeDomSerializer<UnkeyedListEntryNode> {
UnkeyedListEntryNodeDomSerializer(final Document doc, final NodeSerializerDispatcher<Element> dispatcher) {
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.w3c.dom.Element;
+@Deprecated
final class UnkeyedListNodeDomSerializer extends ListNodeBaseSerializer<Element, UnkeyedListNode, UnkeyedListEntryNode> {
private final FromNormalizedNodeSerializer<Element, UnkeyedListEntryNode, ListSchemaNode> unkeyedListEntrySerializer;
- UnkeyedListNodeDomSerializer(UnkeyedListEntryNodeDomSerializer unkeyedListEntrySerializer) {
+ UnkeyedListNodeDomSerializer(final UnkeyedListEntryNodeDomSerializer unkeyedListEntrySerializer) {
this.unkeyedListEntrySerializer = unkeyedListEntrySerializer;
}
Code Review / yangtools.git / commitdiff