import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
/**
}
- static SchemaContext createTestContext() {
+ static EffectiveModelContext createTestContext() {
return YangParserTestUtils.parseYangResource("/odl-datastore-test.yang");
}
}
package org.opendaylight.yangtools.yang.data.api.schema.tree;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
/**
* Interface representing a data tree which can be modified in an MVCC fashion.
*/
public interface DataTree extends DataTreeTip, ReadOnlyDataTree {
- /**
- * Make the data tree use a new schema context. The context will be used
- * only by subsequent operations.
- *
- * @param newSchemaContext new SchemaContext
- * @throws IllegalArgumentException if the new context is incompatible
- * @throws NullPointerException if newSchemaContext is null
- * @deprecated Prefer {@link #setEffectiveModelContext(EffectiveModelContext)}.
- */
- @Deprecated
- void setSchemaContext(SchemaContext newSchemaContext);
-
/**
* Make the data tree use a new schema context. The context will be used
* only by subsequent operations.
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
/**
* Factory interface for creating data trees.
* <p>
* Correctness note: this method may not accurately initialize the root node in certain non-root scenarios due to
* the impossibility to accurately derive root type from plain YangInstanceIdentifier. Using
- * {@link #create(DataTreeConfiguration, SchemaContext)} is recommended, as it does not suffer from this
+ * {@link #create(DataTreeConfiguration, EffectiveModelContext)} is recommended, as it does not suffer from this
* shortcoming.
*
* @param treeConfig
* @throws IllegalArgumentException if tree configuration does not match the SchemaContext, for example by root path
* referring to a node which does not exist in the SchemaContext
*/
- @NonNull DataTree create(DataTreeConfiguration treeConfig, SchemaContext initialSchemaContext);
+ @NonNull DataTree create(DataTreeConfiguration treeConfig, EffectiveModelContext initialSchemaContext);
/**
* Create a new data tree based on specified configuration, with the specified node.
* @throws NullPointerException if any of the arguments are null
* @throws IllegalArgumentException if a mismatch between the arguments is detected
*/
- @NonNull DataTree create(DataTreeConfiguration treeConfig, SchemaContext initialSchemaContext,
+ @NonNull DataTree create(DataTreeConfiguration treeConfig, EffectiveModelContext initialSchemaContext,
NormalizedNodeContainer<?, ?, ?> initialRoot) throws DataValidationFailedException;
}
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextProvider;
/**
* Read-only snapshot of a {@link DataTree}. The snapshot is stable and isolated, e.g. data tree changes occurring after
* the snapshot has been taken are not visible through the snapshot.
*/
-public interface DataTreeSnapshot extends SchemaContextProvider {
+public interface DataTreeSnapshot extends EffectiveModelContextProvider {
/**
* Read a particular node from the snapshot.
*
import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
/**
* A {@link DataTreeModification} implementation which delegates all calls to
}
@Override
- public synchronized SchemaContext getSchemaContext() {
- return delegate.getSchemaContext();
+ public synchronized EffectiveModelContext getEffectiveModelContext() {
+ return delegate.getEffectiveModelContext();
}
}
import org.opendaylight.yangtools.yang.data.util.codec.CodecCache;
import org.opendaylight.yangtools.yang.data.util.codec.LazyCodecCache;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
/**
* Factory for creating JSON equivalents of codecs. Each instance of this object is bound to
- * a particular {@link SchemaContext}, but can be reused by multiple {@link JSONNormalizedNodeStreamWriter}s.
+ * a particular {@link EffectiveModelContext}, but can be reused by multiple {@link JSONNormalizedNodeStreamWriter}s.
*/
@Beta
public abstract class JSONCodecFactory extends AbstractCodecFactory<JSONCodec<?>> {
import org.opendaylight.yangtools.yang.data.util.AbstractModuleStringInstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
abstract class JSONInstanceIdentifierCodec extends AbstractModuleStringInstanceIdentifierCodec
implements JSONCodec<YangInstanceIdentifier> {
private final DataSchemaContextTree dataContextTree;
private final JSONCodecFactory codecFactory;
- private final SchemaContext context;
+ private final EffectiveModelContext context;
- JSONInstanceIdentifierCodec(final SchemaContext context, final JSONCodecFactory jsonCodecFactory) {
+ JSONInstanceIdentifierCodec(final EffectiveModelContext context, final JSONCodecFactory jsonCodecFactory) {
this.context = requireNonNull(context);
this.dataContextTree = DataSchemaContextTree.from(context);
this.codecFactory = requireNonNull(jsonCodecFactory);
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
final class Lhotka02JSONInstanceIdentifierCodec extends JSONInstanceIdentifierCodec {
- Lhotka02JSONInstanceIdentifierCodec(final SchemaContext context, final JSONCodecFactory jsonCodecFactory) {
+ Lhotka02JSONInstanceIdentifierCodec(final EffectiveModelContext context, final JSONCodecFactory jsonCodecFactory) {
super(context, jsonCodecFactory);
}
}
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
final class RFC7951JSONInstanceIdentifierCodec extends JSONInstanceIdentifierCodec {
- RFC7951JSONInstanceIdentifierCodec(final SchemaContext context, final JSONCodecFactory jsonCodecFactory) {
+ RFC7951JSONInstanceIdentifierCodec(final EffectiveModelContext context, final JSONCodecFactory jsonCodecFactory) {
super(context, jsonCodecFactory);
}
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.util.codec.IdentityCodecUtil;
import org.opendaylight.yangtools.yang.data.util.codec.QNameCodecUtil;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
final class IdentityrefXmlCodec implements XmlCodec<QName> {
- private final SchemaContext schemaContext;
+ private final EffectiveModelContext schemaContext;
private final QNameModule parentModule;
- IdentityrefXmlCodec(final SchemaContext context, final QNameModule parentModule) {
+ IdentityrefXmlCodec(final EffectiveModelContext context, final QNameModule parentModule) {
this.schemaContext = requireNonNull(context);
this.parentModule = requireNonNull(parentModule);
}
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.util.AbstractStringInstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
final class RandomPrefixInstanceIdentifierSerializer extends AbstractStringInstanceIdentifierCodec {
private final @NonNull DataSchemaContextTree schemaTree;
private final RandomPrefix prefixes;
- RandomPrefixInstanceIdentifierSerializer(final @NonNull SchemaContext schemaContext,
- final NamespaceContext nsContext) {
+ RandomPrefixInstanceIdentifierSerializer(final @NonNull EffectiveModelContext schemaContext,
+ final NamespaceContext nsContext) {
schemaTree = DataSchemaContextTree.from(schemaContext);
prefixes = new RandomPrefix(nsContext);
}
import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextProvider;
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.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.TypedDataSchemaNode;
final class SchemaAwareXMLStreamNormalizedNodeStreamWriter
- extends XMLStreamNormalizedNodeStreamWriter<TypedDataSchemaNode> implements SchemaContextProvider {
+ extends XMLStreamNormalizedNodeStreamWriter<TypedDataSchemaNode> implements EffectiveModelContextProvider {
private final SchemaTracker tracker;
private final SchemaAwareXMLStreamWriterUtils streamUtils;
- SchemaAwareXMLStreamNormalizedNodeStreamWriter(final XMLStreamWriter writer, final SchemaContext context,
+ SchemaAwareXMLStreamNormalizedNodeStreamWriter(final XMLStreamWriter writer, final EffectiveModelContext context,
final SchemaTracker tracker) {
super(writer);
this.tracker = requireNonNull(tracker);
@Override
String encodeAnnotationValue(final ValueWriter xmlWriter, final QName qname, final Object value)
throws XMLStreamException {
- final Optional<AnnotationSchemaNode> optAnnotation = AnnotationSchemaNode.find(streamUtils.getSchemaContext(),
- qname);
+ final Optional<AnnotationSchemaNode> optAnnotation =
+ AnnotationSchemaNode.find(streamUtils.getEffectiveModelContext(), qname);
if (optAnnotation.isPresent()) {
final AnnotationSchemaNode schema = optAnnotation.get();
return streamUtils.encodeValue(xmlWriter, schema, schema.getType(), value, qname.getModule());
}
@Override
- public SchemaContext getSchemaContext() {
- return streamUtils.getSchemaContext();
+ public EffectiveModelContext getEffectiveModelContext() {
+ return streamUtils.getEffectiveModelContext();
}
@Override
import javax.xml.stream.XMLStreamException;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextProvider;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
-final class SchemaAwareXMLStreamWriterUtils extends XMLStreamWriterUtils implements SchemaContextProvider {
- private final @NonNull SchemaContext schemaContext;
+final class SchemaAwareXMLStreamWriterUtils extends XMLStreamWriterUtils implements EffectiveModelContextProvider {
+ private final @NonNull EffectiveModelContext schemaContext;
- SchemaAwareXMLStreamWriterUtils(final SchemaContext schemaContext) {
+ SchemaAwareXMLStreamWriterUtils(final EffectiveModelContext schemaContext) {
this.schemaContext = requireNonNull(schemaContext);
}
}
@Override
- public SchemaContext getSchemaContext() {
+ public EffectiveModelContext getEffectiveModelContext() {
return schemaContext;
}
}
void emitNormalizedAnydata(final NormalizedAnydata anydata) throws XMLStreamException {
flushElement();
try {
- anydata.writeTo(XMLStreamNormalizedNodeStreamWriter.create(writer, anydata.getSchemaContext(),
+ anydata.writeTo(XMLStreamNormalizedNodeStreamWriter.create(writer, anydata.getEffectiveModelContext(),
new SingleChildDataNodeContainer(anydata.getContextNode())));
} catch (IOException e) {
throw new XMLStreamException("Failed to emit anydata " + anydata, e);
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriterExtension;
import org.opendaylight.yangtools.yang.data.impl.codec.SchemaTracker;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* Create a new writer with the specified context as its root.
*
* @param writer Output {@link XMLStreamWriter}
- * @param context Associated {@link SchemaContext}.
+ * @param context Associated {@link EffectiveModelContext}.
* @return A new {@link NormalizedNodeStreamWriter}
*/
public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer,
- final SchemaContext context) {
+ final EffectiveModelContext context) {
return create(writer, context, context);
}
* Create a new writer with the specified context and rooted at the specified node.
*
* @param writer Output {@link XMLStreamWriter}
- * @param context Associated {@link SchemaContext}.
+ * @param context Associated {@link EffectiveModelContext}.
* @param rootNode Root node
* @return A new {@link NormalizedNodeStreamWriter}
*/
- public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer, final SchemaContext context,
- final DataNodeContainer rootNode) {
+ public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer,
+ final EffectiveModelContext context, final DataNodeContainer rootNode) {
return new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, context, SchemaTracker.create(rootNode));
}
* Create a new writer with the specified context and rooted in the specified schema path.
*
* @param writer Output {@link XMLStreamWriter}
- * @param context Associated {@link SchemaContext}.
+ * @param context Associated {@link EffectiveModelContext}.
* @param path path
* @return A new {@link NormalizedNodeStreamWriter}
*/
- public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer, final SchemaContext context,
- final SchemaPath path) {
+ public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer,
+ final EffectiveModelContext context, final SchemaPath path) {
return new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, context, SchemaTracker.create(context, path));
}
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
@Test
public void test() throws Exception {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResource("/bug5446/yang/foo.yang");
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResource("/bug5446/yang/foo.yang");
final Document doc = loadDocument("/bug5446/xml/foo.xml");
final ContainerNode docNode = createDocNode();
.build();
}
- private static DOMResult writeNormalizedNode(final ContainerNode normalized, final SchemaContext context)
+ private static DOMResult writeNormalizedNode(final ContainerNode normalized, final EffectiveModelContext context)
throws IOException, XMLStreamException {
final Document doc = UntrustedXML.newDocumentBuilder().newDocument();
final DOMResult result = new DOMResult(doc);
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
private QName mySecondKeyLeaf;
private QName myLeafInList3;
- private static SchemaContext SCHEMA_CONTEXT;
+ private static EffectiveModelContext SCHEMA_CONTEXT;
private final XMLOutputFactory factory;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.SchemaOrderedNormalizedNodeWriter;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.xml.sax.SAXException;
final StringWriter stringWriter = new StringWriter();
final XMLStreamWriter xmlStreamWriter = factory.createXMLStreamWriter(stringWriter);
- SchemaContext schemaContext = getSchemaContext("/bug1848/foo.yang");
+ EffectiveModelContext schemaContext = getSchemaContext("/bug1848/foo.yang");
NormalizedNodeStreamWriter writer = XMLStreamNormalizedNodeStreamWriter.create(xmlStreamWriter, schemaContext);
try (SchemaOrderedNormalizedNodeWriter nnw = new SchemaOrderedNormalizedNodeWriter(writer, schemaContext,
public void testWriteOrder() throws XMLStreamException, IOException, SAXException {
final StringWriter stringWriter = new StringWriter();
final XMLStreamWriter xmlStreamWriter = factory.createXMLStreamWriter(stringWriter);
- SchemaContext schemaContext = getSchemaContext("/bug1848/order.yang");
+ EffectiveModelContext schemaContext = getSchemaContext("/bug1848/order.yang");
NormalizedNodeStreamWriter writer = XMLStreamNormalizedNodeStreamWriter.create(xmlStreamWriter, schemaContext);
try (NormalizedNodeWriter nnw = new SchemaOrderedNormalizedNodeWriter(writer, schemaContext, SchemaPath.ROOT)) {
XMLAssert.assertXMLIdentical(new Diff(EXPECTED_2, stringWriter.toString()), true);
}
- private static SchemaContext getSchemaContext(final String filePath) {
+ private static EffectiveModelContext getSchemaContext(final String filePath) {
return YangParserTestUtils.parseYangResource(filePath);
}
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
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.opendaylight.yangtools.yang.model.api.NotificationDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.util.EffectiveAugmentationSchema;
/**
* Create a new writer with the specified context and rooted in the specified schema path.
*
- * @param context Associated {@link SchemaContext}
+ * @param context Associated {@link EffectiveModelContext}
* @param path schema path
* @return A new {@link NormalizedNodeStreamWriter}
*/
- public static @NonNull SchemaTracker create(final SchemaContext context, final SchemaPath path) {
+ public static @NonNull SchemaTracker create(final EffectiveModelContext context, final SchemaPath path) {
final Collection<SchemaNode> schemaNodes = SchemaUtils.findParentSchemaNodesOnPath(context, path);
checkArgument(!schemaNodes.isEmpty(), "Unable to find schema node for supplied schema path: %s", path);
if (schemaNodes.size() > 1) {
import com.google.common.collect.ImmutableMap;
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.util.AbstractSchemaContextProvider;
this.module = leafRefContextBuilder.getLeafRefContextModule();
}
- public static LeafRefContext create(final SchemaContext ctx) {
+ public static LeafRefContext create(final EffectiveModelContext ctx) {
try {
return new LeafRefContextTreeBuilder(ctx).buildLeafRefContextTree();
} catch (LeafRefYangSyntaxErrorException e) {
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
final class LeafRefContextBuilder implements Builder<LeafRefContext> {
private final QName currentNodeQName;
private final SchemaPath currentNodePath;
- private final SchemaContext schemaContext;
+ private final EffectiveModelContext schemaContext;
private LeafRefPath leafRefTargetPath = null;
private LeafRefPath absoluteLeafRefTargetPath = null;
private boolean isReferencing = false;
LeafRefContextBuilder(final QName currentNodeQName, final SchemaPath currentNodePath,
- final SchemaContext schemaContext) {
+ final EffectiveModelContext schemaContext) {
this.currentNodeQName = requireNonNull(currentNodeQName);
this.currentNodePath = requireNonNull(currentNodePath);
// FIXME: requireNonNull
return currentNodeQName;
}
- SchemaContext getSchemaContext() {
+ EffectiveModelContext getSchemaContext() {
return schemaContext;
}
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.PathExpression;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.TypedDataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
final class LeafRefContextTreeBuilder {
private final List<LeafRefContext> leafRefs = new LinkedList<>();
- private final SchemaContext schemaContext;
+ private final EffectiveModelContext schemaContext;
- LeafRefContextTreeBuilder(final SchemaContext schemaContext) {
+ LeafRefContextTreeBuilder(final EffectiveModelContext schemaContext) {
this.schemaContext = schemaContext;
}
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.slf4j.Logger;
*/
public class SchemaOrderedNormalizedNodeWriter extends NormalizedNodeWriter {
private static final Logger LOG = LoggerFactory.getLogger(SchemaOrderedNormalizedNodeWriter.class);
- private final SchemaContext schemaContext;
+ private final EffectiveModelContext schemaContext;
private final SchemaNode root;
private SchemaNode currentSchemaNode;
* @param path
* path
*/
- public SchemaOrderedNormalizedNodeWriter(final NormalizedNodeStreamWriter writer, final SchemaContext schemaContext,
- final SchemaPath path) {
+ public SchemaOrderedNormalizedNodeWriter(final NormalizedNodeStreamWriter writer,
+ final EffectiveModelContext schemaContext, final SchemaPath path) {
super(writer);
this.schemaContext = schemaContext;
final Collection<SchemaNode> schemaNodes = SchemaUtils.findParentSchemaNodesOnPath(schemaContext, path);
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodes;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
/**
* Instances of this class hold the current state of a DataTree instance.
*/
final class DataTreeState {
private final LatestOperationHolder holder;
- private final SchemaContext schemaContext;
+ private final EffectiveModelContext schemaContext;
private final @NonNull TreeNode root;
private DataTreeState(final TreeNode root) {
schemaContext = null;
}
- private DataTreeState(final TreeNode root, final LatestOperationHolder holder, final SchemaContext schemaContext) {
+ private DataTreeState(final TreeNode root, final LatestOperationHolder holder,
+ final EffectiveModelContext schemaContext) {
// It should be impossible to instantiate a new root without a SchemaContext
this.schemaContext = requireNonNull(schemaContext);
this.holder = requireNonNull(holder);
return new InMemoryDataTreeSnapshot(schemaContext, root, holder.newSnapshot());
}
- DataTreeState withSchemaContext(final SchemaContext newSchemaContext, final ModificationApplyOperation operation) {
+ DataTreeState withSchemaContext(final EffectiveModelContext newSchemaContext,
+ final ModificationApplyOperation operation) {
holder.setCurrent(operation);
return new DataTreeState(root, holder, newSchemaContext);
}
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private volatile DataTreeState state;
InMemoryDataTree(final TreeNode rootNode, final DataTreeConfiguration treeConfig,
- final SchemaContext schemaContext) {
+ final EffectiveModelContext schemaContext) {
this.treeConfig = requireNonNull(treeConfig, "treeConfig");
maskMandatory = true;
state = DataTreeState.createInitial(rootNode);
if (schemaContext != null) {
- setSchemaContext(schemaContext);
+ setEffectiveModelContext(schemaContext);
}
}
InMemoryDataTree(final TreeNode rootNode, final DataTreeConfiguration treeConfig,
- final SchemaContext schemaContext, final DataSchemaNode rootSchemaNode, final boolean maskMandatory) {
+ final EffectiveModelContext schemaContext, final DataSchemaNode rootSchemaNode,
+ final boolean maskMandatory) {
this.treeConfig = requireNonNull(treeConfig, "treeConfig");
this.maskMandatory = maskMandatory;
}
}
- @Deprecated
- @Override
- public void setSchemaContext(final SchemaContext newSchemaContext) {
- internalSetSchemaContext(newSchemaContext);
- }
-
@Override
public void setEffectiveModelContext(final EffectiveModelContext newModelContext) {
internalSetSchemaContext(newModelContext);
* This method is synchronized to guard against user attempting to install
* multiple contexts. Otherwise it runs in a lock-free manner.
*/
- private synchronized void internalSetSchemaContext(final SchemaContext newSchemaContext) {
+ private synchronized void internalSetSchemaContext(final EffectiveModelContext newSchemaContext) {
requireNonNull(newSchemaContext);
LOG.debug("Following schema contexts will be attempted {}", newSchemaContext);
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.osgi.service.component.annotations.Activate;
}
@Override
- public DataTree create(final DataTreeConfiguration treeConfig, final SchemaContext initialSchemaContext) {
+ public DataTree create(final DataTreeConfiguration treeConfig, final EffectiveModelContext initialSchemaContext) {
return createDataTree(treeConfig, initialSchemaContext, true);
}
@Override
- public DataTree create(final DataTreeConfiguration treeConfig, final SchemaContext initialSchemaContext,
+ public DataTree create(final DataTreeConfiguration treeConfig, final EffectiveModelContext initialSchemaContext,
final NormalizedNodeContainer<?, ?, ?> initialRoot) throws DataValidationFailedException {
final DataTree ret = createDataTree(treeConfig, initialSchemaContext, false);
}
private static @NonNull DataTree createDataTree(final DataTreeConfiguration treeConfig,
- final SchemaContext initialSchemaContext, final boolean maskMandatory) {
+ final EffectiveModelContext initialSchemaContext, final boolean maskMandatory) {
final DataSchemaNode rootSchemaNode = getRootSchemaNode(initialSchemaContext, treeConfig.getRootPath());
final NormalizedNode<?, ?> rootDataNode = createRoot((DataNodeContainer)rootSchemaNode,
treeConfig.getRootPath());
throw new IllegalArgumentException("Unsupported root node " + arg);
}
- private static DataSchemaNode getRootSchemaNode(final SchemaContext schemaContext,
+ private static DataSchemaNode getRootSchemaNode(final EffectiveModelContext schemaContext,
final YangInstanceIdentifier rootPath) {
final DataSchemaContextTree contextTree = DataSchemaContextTree.from(schemaContext);
final Optional<DataSchemaContextNode<?>> rootContextNode = contextTree.findChild(rootPath);
import org.opendaylight.yangtools.yang.data.api.schema.tree.StoreTreeNodes;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
final class InMemoryDataTreeModification extends AbstractCursorAware implements CursorAwareDataTreeModification,
- SchemaContextProvider {
+ EffectiveModelContextProvider {
private static final Logger LOG = LoggerFactory.getLogger(InMemoryDataTreeModification.class);
private final RootApplyStrategy strategyTree;
}
@Override
- public SchemaContext getSchemaContext() {
- return snapshot.getSchemaContext();
+ public EffectiveModelContext getEffectiveModelContext() {
+ return snapshot.getEffectiveModelContext();
}
@Override
version);
checkState(tempRoot.isPresent(), "Data tree root is not present, possibly removed by previous modification");
- final InMemoryDataTreeSnapshot tempTree = new InMemoryDataTreeSnapshot(snapshot.getSchemaContext(),
+ final InMemoryDataTreeSnapshot tempTree = new InMemoryDataTreeSnapshot(snapshot.getEffectiveModelContext(),
tempRoot.get(), strategyTree);
return tempTree.newModification();
}
import org.opendaylight.yangtools.yang.data.api.schema.tree.CursorAwareDataTreeSnapshot;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshotCursor;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextProvider;
final class InMemoryDataTreeSnapshot extends AbstractCursorAware implements CursorAwareDataTreeSnapshot,
- SchemaContextProvider {
+ EffectiveModelContextProvider {
private final @NonNull RootApplyStrategy applyOper;
- private final @NonNull SchemaContext schemaContext;
+ private final @NonNull EffectiveModelContext schemaContext;
private final @NonNull TreeNode rootNode;
- InMemoryDataTreeSnapshot(final SchemaContext schemaContext, final TreeNode rootNode,
+ InMemoryDataTreeSnapshot(final EffectiveModelContext schemaContext, final TreeNode rootNode,
final RootApplyStrategy applyOper) {
this.schemaContext = requireNonNull(schemaContext);
this.rootNode = requireNonNull(rootNode);
}
@Override
- public SchemaContext getSchemaContext() {
+ public EffectiveModelContext getEffectiveModelContext() {
return schemaContext;
}
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class Bug7844Test {
@Test
public void test() {
- final SchemaContext context = YangParserTestUtils.parseYangResourceDirectory("/bug7844");
+ final EffectiveModelContext context = YangParserTestUtils.parseYangResourceDirectory("/bug7844");
assertNotNull(context);
final LeafRefContext leafRefContext = LeafRefContext.create(context);
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class YT821Test {
private static final QName REF_IN_CONTAINER = QName.create(ROOT, "ref-in-container");
private static final YangInstanceIdentifier ROOT_ID = YangInstanceIdentifier.of(ROOT);
- private static SchemaContext schemaContext;
+ private static EffectiveModelContext schemaContext;
private static LeafRefContext leafRefContext;
private DataTree dataTree;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class YT891Test {
private static final QName LIST_IN_CONTAINER = QName.create(BAZ_TOP, "list-in-container");
private static final YangInstanceIdentifier BAZ_TOP_ID = YangInstanceIdentifier.of(BAZ_TOP);
- private static SchemaContext schemaContext;
+ private static EffectiveModelContext schemaContext;
private static LeafRefContext leafRefContext;
private DataTree dataTree;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class YT892Test {
@Before
public void setup() {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResourceDirectory("/yt892");
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResourceDirectory("/yt892");
leafRefContext = LeafRefContext.create(schemaContext);
dataTree = new InMemoryDataTreeFactory().create(DataTreeConfiguration.DEFAULT_CONFIGURATION, schemaContext);
}
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class Bug8713Test {
@Test
public void dataTreeCanditateValidationTest() throws Exception {
- final SchemaContext context = YangParserTestUtils.parseYangResourceDirectory("/bug8713/");
+ final EffectiveModelContext context = YangParserTestUtils.parseYangResourceDirectory("/bug8713/");
final LeafRefContext rootLeafRefContext = LeafRefContext.create(context);
final DataTree inMemoryDataTree = new InMemoryDataTreeFactory().create(
DataTreeConfiguration.DEFAULT_OPERATIONAL, context);
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class DataTreeCandidateValidatorTest {
- private static SchemaContext context;
+ private static EffectiveModelContext context;
private static Module valModule;
private static QNameModule valModuleQname;
private static LeafRefContext rootLeafRefContext;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class DataTreeCandidateValidatorTest2 {
- private static SchemaContext context;
+ private static EffectiveModelContext context;
private static Module mainModule;
private static QNameModule rootModuleQname;
private static LeafRefContext rootLeafRefContext;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class DataTreeCandidateValidatorTest3 {
- private static SchemaContext context;
+ private static EffectiveModelContext context;
private static Module mainModule;
private static QNameModule rootModuleQname;
private static LeafRefContext rootLeafRefContext;
import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefContext;
import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefContextUtils;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class LeafRefContextTest {
- private static SchemaContext context;
+ private static EffectiveModelContext context;
private static Module rootMod;
private static QNameModule root;
private static LeafRefContext rootLeafRefContext;
import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefContext;
import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefContextUtils;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.parser.api.YangParserException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
public class LeafRefContextTreeBuilderTest {
private static final Logger LOG = LoggerFactory.getLogger(LeafRefContextTreeBuilderTest.class);
- private static SchemaContext context;
+ private static EffectiveModelContext context;
private static Module tstMod;
private static QNameModule tst;
private static LeafRefContext rootLeafRefContext;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class Bug4454Test {
.withNodeIdentifier(new NodeIdentifier(MIN_MAX_LIST_QNAME))
.withChild(bazEntryNode).build();
- private static SchemaContext schemaContext;
+ private static EffectiveModelContext schemaContext;
private DataTree inMemoryDataTree;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
public class Bug5830Test {
private static final String NS = "foo";
private static final QName PRESENCE_CONTAINER_2 = QName.create(NS, REV, "presence-container-2");
private static final QName MANDATORY_LEAF_2 = QName.create(NS, REV, "mandatory-leaf-2");
- private static DataTree initDataTree(final SchemaContext schemaContext)
+ private static DataTree initDataTree(final EffectiveModelContext schemaContext)
throws DataValidationFailedException {
DataTree inMemoryDataTree = new InMemoryDataTreeFactory().create(
DataTreeConfiguration.DEFAULT_CONFIGURATION, schemaContext);
}
private static void testPresenceContainer() throws DataValidationFailedException {
- final SchemaContext schemaContext = TestModel.createTestContext("/bug5830/foo-presence.yang");
+ final EffectiveModelContext schemaContext = TestModel.createTestContext("/bug5830/foo-presence.yang");
assertNotNull("Schema context must not be null.", schemaContext);
testContainerIsNotPresent(schemaContext);
}
private static void testNonPresenceContainer() throws DataValidationFailedException {
- final SchemaContext schemaContext = TestModel.createTestContext("/bug5830/foo-non-presence.yang");
+ final EffectiveModelContext schemaContext = TestModel.createTestContext("/bug5830/foo-non-presence.yang");
assertNotNull("Schema context must not be null.", schemaContext);
try {
}
private static void testMultipleContainers() throws DataValidationFailedException {
- final SchemaContext schemaContext = TestModel.createTestContext("/bug5830/foo-multiple.yang");
+ final EffectiveModelContext schemaContext = TestModel.createTestContext("/bug5830/foo-multiple.yang");
assertNotNull("Schema context must not be null.", schemaContext);
testContainerIsNotPresent(schemaContext);
}
}
- private static void testContainerIsNotPresent(final SchemaContext schemaContext)
+ private static void testContainerIsNotPresent(final EffectiveModelContext schemaContext)
throws DataValidationFailedException {
final DataTree inMemoryDataTree = initDataTree(schemaContext);
final MapEntryNode taskEntryNode = Builders.mapEntryBuilder()
inMemoryDataTree.commit(prepare);
}
- private static void testContainerIsPresent(final SchemaContext schemaContext) throws DataValidationFailedException {
+ private static void testContainerIsPresent(final EffectiveModelContext schemaContext)
+ throws DataValidationFailedException {
final DataTree inMemoryDataTree = initDataTree(schemaContext);
final MapEntryNode taskEntryNode = Builders.mapEntryBuilder()
inMemoryDataTree.commit(prepare);
}
- private static void testMandatoryDataLeafIsPresent(final SchemaContext schemaContext)
+ private static void testMandatoryDataLeafIsPresent(final EffectiveModelContext schemaContext)
throws DataValidationFailedException {
final DataTree inMemoryDataTree = initDataTree(schemaContext);
inMemoryDataTree.commit(prepare);
}
- private static void testMandatoryLeaf2IsPresent(final SchemaContext schemaContext,
+ private static void testMandatoryLeaf2IsPresent(final EffectiveModelContext schemaContext,
final boolean withPresenceContianer) throws DataValidationFailedException {
final DataTree inMemoryDataTree = initDataTree(schemaContext);
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
public class Bug5968MergeTest {
private static final String NS = "foo";
private static final QName LIST_ID = QName.create(NS, REV, "list-id");
private static final QName MANDATORY_LEAF = QName.create(NS, REV, "mandatory-leaf");
private static final QName COMMON_LEAF = QName.create(NS, REV, "common-leaf");
- private static SchemaContext SCHEMA_CONTEXT;
+ private static EffectiveModelContext SCHEMA_CONTEXT;
@BeforeClass
public static void beforeClass() {
SCHEMA_CONTEXT = null;
}
- private static DataTree initDataTree(final SchemaContext schemaContext, final boolean withMapNode)
+ private static DataTree initDataTree(final EffectiveModelContext schemaContext, final boolean withMapNode)
throws DataValidationFailedException {
final DataTree inMemoryDataTree = new InMemoryDataTreeFactory().create(
DataTreeConfiguration.DEFAULT_CONFIGURATION, schemaContext);
return inMemoryDataTree;
}
- private static DataTree emptyDataTree(final SchemaContext schemaContext)
+ private static DataTree emptyDataTree(final EffectiveModelContext schemaContext)
throws DataValidationFailedException {
return new InMemoryDataTreeFactory().create(DataTreeConfiguration.DEFAULT_CONFIGURATION, schemaContext);
}
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
public class Bug5968Test {
private static final String NS = "foo";
private static final QName MANDATORY_LEAF = QName.create(NS, REV, "mandatory-leaf");
private static final QName COMMON_LEAF = QName.create(NS, REV, "common-leaf");
- private static SchemaContext SCHEMA_CONTEXT;
+ private static EffectiveModelContext SCHEMA_CONTEXT;
@BeforeClass
public static void beforeClass() {
SCHEMA_CONTEXT = null;
}
- private static DataTree initDataTree(final SchemaContext schemaContext, final boolean withMapNode)
+ private static DataTree initDataTree(final EffectiveModelContext schemaContext, final boolean withMapNode)
throws DataValidationFailedException {
final DataTree inMemoryDataTree = new InMemoryDataTreeFactory().create(
DataTreeConfiguration.DEFAULT_CONFIGURATION, schemaContext);
return inMemoryDataTree;
}
- private static DataTree emptyDataTree(final SchemaContext schemaContext)
+ private static DataTree emptyDataTree(final EffectiveModelContext schemaContext)
throws DataValidationFailedException {
return new InMemoryDataTreeFactory().create(DataTreeConfiguration.DEFAULT_CONFIGURATION, schemaContext);
}
import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
public class Bug8291Test {
private static final String NS = "foo";
private static final QName OUTER_LIST = QName.create(NS, "outer-list");
private static final QName OUTER_LIST_ID = QName.create(NS, "id");
private static final QName INNER_LIST = QName.create(NS, "inner-list");
- private SchemaContext schemaContext;
+
+ private EffectiveModelContext schemaContext;
@Before
public void init() {
assertNotNull("Schema context must not be null.", this.schemaContext);
}
- private static DataTree initDataTree(final SchemaContext schemaContext)
+ private static DataTree initDataTree(final EffectiveModelContext schemaContext)
throws DataValidationFailedException {
final DataTreeConfiguration config = new DataTreeConfiguration.Builder(TreeType.CONFIGURATION).setRootPath(
YangInstanceIdentifier.of(ROOT).node(OUTER_LIST)).build();
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
public class CaseAugmentTest {
private static final QName CHOICE1_QNAME = QName.create(TestModel.TEST_QNAME, "choice1");
private static final AugmentationIdentifier AUGMENT_ID = new AugmentationIdentifier(
ImmutableSet.of(C1L2_QNAME, C1L3_QNAME));
- private static SchemaContext SCHEMA_CONTEXT;
+ private static EffectiveModelContext SCHEMA_CONTEXT;
@BeforeClass
public static void beforeClass() {
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
public class CaseExclusionTest {
- private static SchemaContext SCHEMA_CONTEXT;
+ private static EffectiveModelContext SCHEMA_CONTEXT;
private DataTree inMemoryDataTree;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUnkeyedListEntryNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUnkeyedListNodeBuilder;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class ListConstraintsValidation {
private static final YangInstanceIdentifier UNKEYED_LIST_PATH = YangInstanceIdentifier
.builder(MASTER_CONTAINER_PATH).node(UNKEYED_LIST_QNAME).build();
- private static SchemaContext schemaContext;
+ private static EffectiveModelContext schemaContext;
private DataTree inMemoryDataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
public class MandatoryLeafTest {
-
- private static SchemaContext SCHEMA_CONTEXT;
+ private static EffectiveModelContext SCHEMA_CONTEXT;
@BeforeClass
public static void beforeClass() {
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeConfiguration;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
public class YT776Test {
private static final QName MODULE = QName.create("yt776", "yt776");
private static final NodeIdentifier SOME_LIST_ID = new NodeIdentifier(SOME_LIST);
private static final NodeIdentifierWithPredicates SOME_LIST_ITEM = NodeIdentifierWithPredicates.of(SOME_LIST,
ImmutableMap.of(SOME_LEAF, "foo"));
- private static SchemaContext SCHEMA_CONTEXT;
+ private static EffectiveModelContext SCHEMA_CONTEXT;
private DataTree dataTree;
import org.opendaylight.yangtools.yang.data.jaxen.api.XPathExpression;
import org.opendaylight.yangtools.yang.data.jaxen.api.XPathSchemaContext;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
@NonNullByDefault
final class JaxenSchemaContext implements XPathSchemaContext {
private final DataSchemaContextTree tree;
- private final SchemaContext context;
+ private final EffectiveModelContext context;
- JaxenSchemaContext(final SchemaContext context) {
+ JaxenSchemaContext(final EffectiveModelContext context) {
this.context = requireNonNull(context);
this.tree = DataSchemaContextTree.from(context);
}
import org.kohsuke.MetaInfServices;
import org.opendaylight.yangtools.yang.data.jaxen.api.XPathSchemaContext;
import org.opendaylight.yangtools.yang.data.jaxen.api.XPathSchemaContextFactory;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
@MetaInfServices
@NonNullByDefault
public final class JaxenSchemaContextFactory implements XPathSchemaContextFactory {
@Override
- public XPathSchemaContext createContext(final SchemaContext context) {
+ public XPathSchemaContext createContext(final EffectiveModelContext context) {
return new JaxenSchemaContext(context);
}
}
package org.opendaylight.yangtools.yang.data.jaxen.api;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
/**
* A factory for obtaining {@link XPathSchemaContext}s. This is the primary entry point to an XPath evaluation
@NonNullByDefault
public interface XPathSchemaContextFactory {
/**
- * Create an {@link XPathSchemaContext} based on a {@link SchemaContext}. This effectively binds the namespaces
- * the user expects to map to YANG schema. The {@link XPathExpression} compilation, relocation and optimization
- * processes can take advantage of the YANG schema provided.
+ * Create an {@link XPathSchemaContext} based on a {@link EffectiveModelContext}. This effectively binds the
+ * namespaces the user expects to map to YANG schema. The {@link XPathExpression} compilation, relocation and
+ * optimization processes can take advantage of the YANG schema provided.
*
* @param context SchemaContext associated with the resulting {@link XPathSchemaContext}
* @return An {@link XPathSchemaContext} instance
*/
- XPathSchemaContext createContext(SchemaContext context);
+ XPathSchemaContext createContext(EffectiveModelContext context);
}
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.jaxen.api.XPathDocument;
import org.opendaylight.yangtools.yang.data.jaxen.api.XPathSchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class BitIsSetXPathFunctionTest {
public void testBitIsSetFunction() throws Exception {
final Set<String> setOfBits = ImmutableSet.of("UP", "PROMISCUOUS");
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResources(BitIsSetXPathFunctionTest.class,
- "/yang-xpath-functions-test/bit-is-set-function/foo.yang");
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(
+ BitIsSetXPathFunctionTest.class, "/yang-xpath-functions-test/bit-is-set-function/foo.yang");
assertNotNull(schemaContext);
final XPathSchemaContext jaxenSchemaContext = SCHEMA_CONTEXT_FACTORY.createContext(schemaContext);
public void testInvalidTypeOfCorrespondingSchemaNode() throws Exception {
final Set<String> setOfBits = ImmutableSet.of("UP", "PROMISCUOUS");
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResources(BitIsSetXPathFunctionTest.class,
- "/yang-xpath-functions-test/bit-is-set-function/foo-invalid.yang");
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(
+ BitIsSetXPathFunctionTest.class, "/yang-xpath-functions-test/bit-is-set-function/foo-invalid.yang");
assertNotNull(schemaContext);
final XPathSchemaContext jaxenSchemaContext = SCHEMA_CONTEXT_FACTORY.createContext(schemaContext);
public void testInvalidNormalizedNodeValueType() throws Exception {
final String invalidNodeValueType = "value of invalid type";
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResources(BitIsSetXPathFunctionTest.class,
- "/yang-xpath-functions-test/bit-is-set-function/foo.yang");
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(
+ BitIsSetXPathFunctionTest.class, "/yang-xpath-functions-test/bit-is-set-function/foo.yang");
assertNotNull(schemaContext);
final XPathSchemaContext jaxenSchemaContext = SCHEMA_CONTEXT_FACTORY.createContext(schemaContext);
public void shouldFailOnUnknownBitArgument() throws Exception {
final Set<String> setOfBits = ImmutableSet.of("UP", "PROMISCUOUS");
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResources(BitIsSetXPathFunctionTest.class,
- "/yang-xpath-functions-test/bit-is-set-function/foo.yang");
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(
+ BitIsSetXPathFunctionTest.class, "/yang-xpath-functions-test/bit-is-set-function/foo.yang");
assertNotNull(schemaContext);
final XPathSchemaContext jaxenSchemaContext = SCHEMA_CONTEXT_FACTORY.createContext(schemaContext);
import org.opendaylight.yangtools.yang.data.impl.schema.nodes.LazyLeafOperations;
import org.opendaylight.yangtools.yang.data.jaxen.api.XPathDocument;
import org.opendaylight.yangtools.yang.data.jaxen.api.XPathSchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class DerefXPathFunctionTest {
@Test
public void testDerefFunctionForInstanceIdentifier() throws Exception {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResources(DerefXPathFunctionTest.class,
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(DerefXPathFunctionTest.class,
"/yang-xpath-functions-test/deref-function-iid/foo.yang");
assertNotNull(schemaContext);
@Test
public void testDerefFunctionForLeafref() throws Exception {
// tests absolute and relative leafref that references a leaf node
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResources(DerefXPathFunctionTest.class,
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(DerefXPathFunctionTest.class,
"/yang-xpath-functions-test/deref-function-leafref/foo.yang");
assertNotNull(schemaContext);
@Test
public void testDerefFunctionForLeafref2() throws Exception {
// tests leafref that references a leaf-list node
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResources(DerefXPathFunctionTest.class,
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(DerefXPathFunctionTest.class,
"/yang-xpath-functions-test/deref-function-leafref/foo.yang");
assertNotNull(schemaContext);
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.jaxen.api.XPathDocument;
import org.opendaylight.yangtools.yang.data.jaxen.api.XPathSchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class DerivedFromXPathFunctionTest {
@Test
public void testDerivedFromFunction() throws Exception {
// also includes test for derived-from-or-self function
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResources(DerivedFromXPathFunctionTest.class,
- "/yang-xpath-functions-test/derived-from-function/foo.yang",
- "/yang-xpath-functions-test/derived-from-function/bar.yang");
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(
+ DerivedFromXPathFunctionTest.class,
+ "/yang-xpath-functions-test/derived-from-function/foo.yang",
+ "/yang-xpath-functions-test/derived-from-function/bar.yang");
assertNotNull(schemaContext);
final XPathSchemaContext jaxenSchemaContext = SCHEMA_CONTEXT_FACTORY.createContext(schemaContext);
@Test
public void testInvalidTypeOfCorrespondingSchemaNode() throws Exception {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResources(DerivedFromXPathFunctionTest.class,
- "/yang-xpath-functions-test/derived-from-function/bar-invalid.yang");
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(
+ DerivedFromXPathFunctionTest.class, "/yang-xpath-functions-test/derived-from-function/bar-invalid.yang");
assertNotNull(schemaContext);
final XPathSchemaContext jaxenSchemaContext = SCHEMA_CONTEXT_FACTORY.createContext(schemaContext);
@Test
public void testInvalidNormalizedNodeValueType() throws Exception {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResources(DerivedFromXPathFunctionTest.class,
- "/yang-xpath-functions-test/derived-from-function/foo.yang",
- "/yang-xpath-functions-test/derived-from-function/bar.yang");
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(
+ DerivedFromXPathFunctionTest.class,
+ "/yang-xpath-functions-test/derived-from-function/foo.yang",
+ "/yang-xpath-functions-test/derived-from-function/bar.yang");
assertNotNull(schemaContext);
final XPathSchemaContext jaxenSchemaContext = SCHEMA_CONTEXT_FACTORY.createContext(schemaContext);
@Test
public void shouldFailOnUnknownPrefixOfIdentity() throws Exception {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResources(DerivedFromXPathFunctionTest.class,
- "/yang-xpath-functions-test/derived-from-function/foo.yang",
- "/yang-xpath-functions-test/derived-from-function/bar.yang");
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(
+ DerivedFromXPathFunctionTest.class,
+ "/yang-xpath-functions-test/derived-from-function/foo.yang",
+ "/yang-xpath-functions-test/derived-from-function/bar.yang");
assertNotNull(schemaContext);
final XPathSchemaContext jaxenSchemaContext = SCHEMA_CONTEXT_FACTORY.createContext(schemaContext);
@Test
public void shouldFailOnMalformedIdentityArgument() throws Exception {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResources(DerivedFromXPathFunctionTest.class,
- "/yang-xpath-functions-test/derived-from-function/foo.yang",
- "/yang-xpath-functions-test/derived-from-function/bar.yang");
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(
+ DerivedFromXPathFunctionTest.class,
+ "/yang-xpath-functions-test/derived-from-function/foo.yang",
+ "/yang-xpath-functions-test/derived-from-function/bar.yang");
assertNotNull(schemaContext);
final XPathSchemaContext jaxenSchemaContext = SCHEMA_CONTEXT_FACTORY.createContext(schemaContext);
@Test
public void shouldFailOnUnknownIdentityArgument() throws Exception {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResources(DerivedFromXPathFunctionTest.class,
- "/yang-xpath-functions-test/derived-from-function/foo.yang",
- "/yang-xpath-functions-test/derived-from-function/bar.yang");
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(
+ DerivedFromXPathFunctionTest.class,
+ "/yang-xpath-functions-test/derived-from-function/foo.yang",
+ "/yang-xpath-functions-test/derived-from-function/bar.yang");
assertNotNull(schemaContext);
final XPathSchemaContext jaxenSchemaContext = SCHEMA_CONTEXT_FACTORY.createContext(schemaContext);
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.jaxen.api.XPathDocument;
import org.opendaylight.yangtools.yang.data.jaxen.api.XPathSchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class EnumValueXPathFunctionTest {
@Test
public void testEnumValueFunction() throws Exception {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResources(EnumValueXPathFunctionTest.class,
- "/yang-xpath-functions-test/enum-value-function/foo.yang");
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(
+ EnumValueXPathFunctionTest.class, "/yang-xpath-functions-test/enum-value-function/foo.yang");
assertNotNull(schemaContext);
final XPathSchemaContext jaxenSchemaContext = SCHEMA_CONTEXT_FACTORY.createContext(schemaContext);
@Test
public void testInvalidTypeOfCorrespondingSchemaNode() throws Exception {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResources(EnumValueXPathFunctionTest.class,
- "/yang-xpath-functions-test/enum-value-function/foo-invalid.yang");
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(
+ EnumValueXPathFunctionTest.class, "/yang-xpath-functions-test/enum-value-function/foo-invalid.yang");
assertNotNull(schemaContext);
final XPathSchemaContext jaxenSchemaContext = SCHEMA_CONTEXT_FACTORY.createContext(schemaContext);
@Test
public void testInvalidNormalizedNodeValueType() throws Exception {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResources(EnumValueXPathFunctionTest.class,
- "/yang-xpath-functions-test/enum-value-function/foo.yang");
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(
+ EnumValueXPathFunctionTest.class, "/yang-xpath-functions-test/enum-value-function/foo.yang");
assertNotNull(schemaContext);
final XPathSchemaContext jaxenSchemaContext = SCHEMA_CONTEXT_FACTORY.createContext(schemaContext);
@Test
public void shouldFailOnUnknownEnumNodeValue() throws Exception {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResources(EnumValueXPathFunctionTest.class,
- "/yang-xpath-functions-test/enum-value-function/foo.yang");
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResources(
+ EnumValueXPathFunctionTest.class, "/yang-xpath-functions-test/enum-value-function/foo.yang");
assertNotNull(schemaContext);
final XPathSchemaContext jaxenSchemaContext = SCHEMA_CONTEXT_FACTORY.createContext(schemaContext);
import org.opendaylight.yangtools.yang.data.jaxen.api.XPathNodesetResult;
import org.opendaylight.yangtools.yang.data.jaxen.api.XPathResult;
import org.opendaylight.yangtools.yang.data.jaxen.api.XPathSchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
@Before
public void setup() throws XPathExpressionException {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResourceDirectory("/test/documentTest");
+ final EffectiveModelContext schemaContext =
+ YangParserTestUtils.parseYangResourceDirectory("/test/documentTest");
assertNotNull(schemaContext);
initQNames();
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
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.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
/**
return new UnorderedLeafListMixinContextNode(potential);
}
- public static DataSchemaContextNode<?> from(final SchemaContext ctx) {
+ public static DataSchemaContextNode<?> from(final EffectiveModelContext ctx) {
return new ContainerContextNode(ctx);
}
}
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
/**
- * Semantic tree binding a {@link SchemaContext} to a {@link NormalizedNode} tree. Since the layout of the schema
- * and data has differences, the mapping is not trivial -- which is where this class comes in.
+ * Semantic tree binding a {@link EffectiveModelContext} to a {@link NormalizedNode} tree. Since the layout of the
+ * schema and data has differences, the mapping is not trivial -- which is where this class comes in.
*
* @author Robert Varga
*/
// FIXME: 6.0.0: @NonNullByDefault
public final class DataSchemaContextTree {
- private static final LoadingCache<SchemaContext, DataSchemaContextTree> TREES = CacheBuilder.newBuilder()
- .weakKeys().weakValues().build(new CacheLoader<SchemaContext, DataSchemaContextTree>() {
+ private static final LoadingCache<EffectiveModelContext, DataSchemaContextTree> TREES = CacheBuilder.newBuilder()
+ .weakKeys().weakValues().build(new CacheLoader<EffectiveModelContext, DataSchemaContextTree>() {
@Override
- public DataSchemaContextTree load(final SchemaContext key) throws Exception {
+ public DataSchemaContextTree load(final EffectiveModelContext key) {
return new DataSchemaContextTree(key);
}
});
private final DataSchemaContextNode<?> root;
- private DataSchemaContextTree(final SchemaContext ctx) {
+ private DataSchemaContextTree(final EffectiveModelContext ctx) {
root = DataSchemaContextNode.from(ctx);
}
- public static @NonNull DataSchemaContextTree from(final @NonNull SchemaContext ctx) {
+ public static @NonNull DataSchemaContextTree from(final @NonNull EffectiveModelContext ctx) {
return TREES.getUnchecked(ctx);
}
import java.util.Iterator;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextProvider;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
/**
* Base class for implementing identityref codecs on based on module names.
*/
@Beta
public abstract class ModuleStringIdentityrefCodec extends AbstractModuleStringIdentityrefCodec
- implements SchemaContextProvider {
- private final SchemaContext context;
+ implements EffectiveModelContextProvider {
+ private final EffectiveModelContext context;
private final QNameModule parentModule;
- protected ModuleStringIdentityrefCodec(final @NonNull SchemaContext context,
+ protected ModuleStringIdentityrefCodec(final @NonNull EffectiveModelContext context,
final @NonNull QNameModule parentModule) {
this.context = requireNonNull(context);
this.parentModule = requireNonNull(parentModule);
}
@Override
- public final SchemaContext getSchemaContext() {
+ public final EffectiveModelContext getEffectiveModelContext() {
return context;
}
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
/**
* Utility methods for implementing string-to-identity codecs.
* @return Corresponding IdentitySchemaNode.
* @throws IllegalArgumentException if the value is invalid or does not refer to an existing identity
*/
- public static IdentitySchemaNode parseIdentity(final String value, final SchemaContext schemaContext,
+ public static IdentitySchemaNode parseIdentity(final String value, final EffectiveModelContext schemaContext,
final Function<String, QNameModule> prefixToModule) {
final QName qname = QNameCodecUtil.decodeQName(value, prefixToModule);
final Optional<Module> optModule = schemaContext.findModule(qname.getModule());
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class IdentityCodecUtilTest {
private static final QNameModule MODULE = QNameModule.create(URI.create("yangtools846"));
- private static SchemaContext SCHEMA_CONTEXT;
+ private static EffectiveModelContext SCHEMA_CONTEXT;
@BeforeClass
public static void init() {
import com.google.common.annotations.Beta;
import com.google.common.util.concurrent.ListenableFuture;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
/**
* Interface exposed by repository implementations. A schema repository is a logically centralized place for model
- * storage and creation of {@link SchemaContext} instances.
+ * storage and creation of {@link EffectiveModelContext} instances.
*/
@Beta
public interface SchemaRepository {
/**
- * Returns {@link SchemaContextFactory} with supplied configuration.
+ * Returns {@link EffectiveModelContextFactory} with supplied configuration.
*
* @param config configuration of schema context factory.
* @return schema context factory.
@NonNull SchemaContextFactoryConfiguration config);
/**
- * Returns {@link SchemaContextFactory} with {@link SchemaContextFactoryConfiguration#getDefault()}.
+ * Returns {@link EffectiveModelContextFactory} with {@link SchemaContextFactoryConfiguration#getDefault()}.
*
* @return schema context factory.
*/
*/
package org.opendaylight.yangtools.yang.model.util;
-import static java.util.Objects.requireNonNull;
-
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.ImmutableBiMap.Builder;
import org.opendaylight.yangtools.yang.common.BiMapYangNamespaceContext;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.YangNamespaceContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
/**
* Utility {@link YangNamespaceContext} backed by a SchemaContext, resolving namespaces to their module names. This
* @author Robert Varga
*/
@Beta
-public final class ModuleNameNamespaceContext implements YangNamespaceContext, SchemaContextProvider {
+public final class ModuleNameNamespaceContext extends AbstractSchemaContextProvider implements YangNamespaceContext {
private static final long serialVersionUID = 1L;
- @SuppressFBWarnings(value = "SE_BAD_FIELD", justification = "Handled through writeReplace()")
- private final SchemaContext schemaContext;
-
- public ModuleNameNamespaceContext(final SchemaContext schemaContext) {
- this.schemaContext = requireNonNull(schemaContext);
+ @SuppressFBWarnings(value = "SE_NO_SUITABLE_CONSTRUCTOR", justification = "Handled through writeReplace()")
+ public ModuleNameNamespaceContext(final EffectiveModelContext schemaContext) {
+ super(schemaContext);
}
/**
*/
public BiMapYangNamespaceContext toBiMap() {
final Builder<String, QNameModule> builder = ImmutableBiMap.builder();
- for (String name : schemaContext.getModules().stream().map(Module::getName).collect(Collectors.toSet())) {
+ for (String name : getSchemaContext().getModules().stream().map(Module::getName).collect(Collectors.toSet())) {
builder.put(name, findNamespaceForPrefix(name).get());
}
return new BiMapYangNamespaceContext(builder.build());
}
- @Override
- public SchemaContext getSchemaContext() {
- return schemaContext;
- }
-
@Override
public Optional<QNameModule> findNamespaceForPrefix(final String prefix) {
- return schemaContext.findModules(prefix).stream().findFirst().map(Module::getQNameModule);
+ return getSchemaContext().findModules(prefix).stream().findFirst().map(Module::getQNameModule);
}
@Override
public Optional<String> findPrefixForNamespace(final QNameModule namespace) {
- return schemaContext.findModule(namespace).map(Module::getName);
+ return getSchemaContext().findModule(namespace).map(Module::getName);
}
private Object writeReplace() {
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
LOG.info("Yang model files: {} ", yangFiles);
LOG.info("Supported features: {} ", supportedFeatures);
- SchemaContext context = null;
+ EffectiveModelContext context = null;
printMemoryInfo("start");
final Stopwatch stopWatch = Stopwatch.createStarted();
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.YangConstants;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.parser.api.YangParser;
import org.opendaylight.yangtools.yang.model.parser.api.YangParserException;
import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
return name.endsWith(YangConstants.RFC6020_YANG_FILE_EXTENSION) && file.isFile();
};
- static SchemaContext parseYangSources(final List<String> yangLibDirs, final List<String> yangTestFiles,
+ static EffectiveModelContext parseYangSources(final List<String> yangLibDirs, final List<String> yangTestFiles,
final Set<QName> supportedFeatures, final boolean recursiveSearch) throws IOException, YangParserException {
/*
* Current dir "." should be always present implicitly in the list of
return parseYangSources(supportedFeatures, testFiles, libFiles);
}
- static SchemaContext parseYangSources(final Set<QName> supportedFeatures, final List<File> testFiles,
+ static EffectiveModelContext parseYangSources(final Set<QName> supportedFeatures, final List<File> testFiles,
final List<File> libFiles) throws IOException, YangParserException {
checkArgument(!testFiles.isEmpty(), "No yang sources");
parser.addLibSource(YangTextSchemaSource.forFile(file));
}
- return parser.buildSchemaContext();
+ return parser.buildEffectiveModel();
}
private static File findInFiles(final List<File> libFiles, final String yangTestFile) throws IOException {
*
* @return An effective schema context comprised of configured models.
* @throws YangSyntaxErrorException When a syntactic error is encountered.
+ * @deprecated Use {@link #buildEffectiveModel()} instead.
*/
+ @Deprecated(forRemoval = true)
default @NonNull SchemaContext buildSchemaContext() throws YangParserException {
return buildEffectiveModel();
}
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.model.repo.api.EffectiveModelContextFactory;
return sc;
}
- /**
- * Try to parse all currently available yang files and build new schema context.
- *
- * @return new schema context iif there is at least 1 yang file registered and new schema context was successfully
- * built.
- * @deprecated Use {@link #getEffectiveModelContext()} instead.
- */
- @Deprecated(forRemoval = true)
- public Optional<? extends SchemaContext> getSchemaContext() {
- return getEffectiveModelContext();
- }
-
- /**
- * Try to parse all currently available yang files and build new schema context depending on specified parsing mode.
- *
- * @param statementParserMode mode of statement parser
- * @return new schema context iif there is at least 1 yang file registered and
- * new schema context was successfully built.
- * @deprecated Use {@link #getEffectiveModelContext(StatementParserMode)} instead.
- */
- @Deprecated(forRemoval = true)
- public Optional<? extends SchemaContext> getSchemaContext(final StatementParserMode statementParserMode) {
- return getEffectiveModelContext(statementParserMode);
- }
-
@Override
public synchronized FluentFuture<YangTextSchemaSource> getSource(
final SourceIdentifier sourceIdentifier) {
e.getCause().getMessage());
}
- Optional<? extends SchemaContext> schemaContextOptional = yangTextSchemaContextResolver.getSchemaContext();
+ Optional<? extends SchemaContext> schemaContextOptional =
+ yangTextSchemaContextResolver.getEffectiveModelContext();
assertTrue(schemaContextOptional.isPresent());
SchemaContext schemaContext = schemaContextOptional.get();
assertEquals(3, schemaContext.getModules().size());
assertEquals(0, yangTextSchemaContextResolver.getAvailableSources().size());
- schemaContextOptional = yangTextSchemaContextResolver.getSchemaContext();
+ schemaContextOptional = yangTextSchemaContextResolver.getEffectiveModelContext();
assertTrue(schemaContextOptional.isPresent());
schemaContext = schemaContextOptional.get();
assertEquals(0, schemaContext.getModules().size());
Code Review / yangtools.git / commitdiff