import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.util.ImmutableNormalizedAnydata;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
@Beta
@NonNullByDefault
implements MetadataNormalizedAnydata {
private final NormalizedMetadata metadata;
- public ImmutableMetadataNormalizedAnydata(final SchemaContext schemaContext, final DataSchemaNode contextNode,
- final NormalizedNode<?, ?> data, final NormalizedMetadata metadata) {
+ public ImmutableMetadataNormalizedAnydata(final EffectiveModelContext schemaContext,
+ final DataSchemaNode contextNode, final NormalizedNode<?, ?> data, final NormalizedMetadata metadata) {
super(schemaContext, contextNode, data);
this.metadata = requireNonNull(metadata);
}
- public static ImmutableNormalizedAnydata ofOptional(final SchemaContext schemaContext,
+ public static ImmutableNormalizedAnydata ofOptional(final EffectiveModelContext schemaContext,
final DataSchemaNode contextNode, final NormalizedNode<?, ?> data,
final Optional<NormalizedMetadata> metadata) {
return metadata.isPresent()
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.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextProvider;
/**
* The contents of an {@code anydata} node in a normalized format. This representation acts as a schema-bound bridge
*/
@Beta
@NonNullByDefault
-public interface NormalizedAnydata extends Immutable, SchemaContextProvider {
+public interface NormalizedAnydata extends Immutable, EffectiveModelContextProvider {
DataSchemaNode getContextNode();
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 IdentityrefJSONCodec implements JSONCodec<QName> {
- private final SchemaContext schemaContext;
+ private final EffectiveModelContext schemaContext;
private final QNameModule parentModule;
- IdentityrefJSONCodec(final SchemaContext context, final QNameModule parentModule) {
+ IdentityrefJSONCodec(final EffectiveModelContext context, final QNameModule parentModule) {
this.schemaContext = requireNonNull(context);
this.parentModule = requireNonNull(parentModule);
}
import org.opendaylight.yangtools.yang.data.util.codec.AbstractCodecFactory;
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;
*/
@Beta
public abstract class JSONCodecFactory extends AbstractCodecFactory<JSONCodec<?>> {
- JSONCodecFactory(final @NonNull SchemaContext context, final @NonNull CodecCache<JSONCodec<?>> cache) {
+ JSONCodecFactory(final @NonNull EffectiveModelContext context, final @NonNull CodecCache<JSONCodec<?>> cache) {
super(context, cache);
}
@Override
protected final JSONCodec<?> identityRefCodec(final IdentityrefTypeDefinition type, final QNameModule module) {
- return new IdentityrefJSONCodec(getSchemaContext(), module);
+ return new IdentityrefJSONCodec(getEffectiveModelContext(), module);
}
@Override
//
// The above is not currently possible, as we cannot reference JSONCodecFactorySupplier from the
// factory due to that potentially creating a circular reference.
- final JSONCodecFactory rebaseTo(final SchemaContext newSchemaContext) {
+ final JSONCodecFactory rebaseTo(final EffectiveModelContext newSchemaContext) {
return rebaseTo(newSchemaContext, new LazyCodecCache<>());
}
- abstract JSONCodecFactory rebaseTo(SchemaContext newSchemaContext, CodecCache<JSONCodec<?>> newCache);
+ abstract JSONCodecFactory rebaseTo(EffectiveModelContext newSchemaContext, CodecCache<JSONCodec<?>> newCache);
abstract JSONCodec<?> wrapDecimalCodec(DecimalStringCodec decimalCodec);
import org.opendaylight.yangtools.yang.data.util.codec.SharedCodecCache;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.TypedDataSchemaNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*/
RFC7951() {
@Override
- JSONCodecFactory createFactory(final SchemaContext context, final CodecCache<JSONCodec<?>> cache) {
+ JSONCodecFactory createFactory(final EffectiveModelContext context, final CodecCache<JSONCodec<?>> cache) {
return new RFC7951JSONCodecFactory(context, cache);
}
},
*/
DRAFT_LHOTKA_NETMOD_YANG_JSON_02() {
@Override
- JSONCodecFactory createFactory(final SchemaContext context, final CodecCache<JSONCodec<?>> cache) {
+ JSONCodecFactory createFactory(final EffectiveModelContext context, final CodecCache<JSONCodec<?>> cache) {
return new Lhotka02JSONCodecFactory(context, cache);
}
};
private static final Logger LOG = LoggerFactory.getLogger(JSONCodecFactorySupplier.class);
- private static final class EagerCacheLoader extends CacheLoader<SchemaContext, JSONCodecFactory> {
- private final BiFunction<SchemaContext, CodecCache<JSONCodec<?>>, JSONCodecFactory> factorySupplier;
+ private static final class EagerCacheLoader extends CacheLoader<EffectiveModelContext, JSONCodecFactory> {
+ private final BiFunction<EffectiveModelContext, CodecCache<JSONCodec<?>>, JSONCodecFactory> factorySupplier;
- EagerCacheLoader(final BiFunction<SchemaContext, CodecCache<JSONCodec<?>>, JSONCodecFactory> factorySupplier) {
+ EagerCacheLoader(final BiFunction<EffectiveModelContext,
+ CodecCache<JSONCodec<?>>, JSONCodecFactory> factorySupplier) {
this.factorySupplier = requireNonNull(factorySupplier);
}
@Override
- public JSONCodecFactory load(final SchemaContext key) {
+ public JSONCodecFactory load(final EffectiveModelContext key) {
final Stopwatch sw = Stopwatch.createStarted();
final LazyCodecCache<JSONCodec<?>> lazyCache = new LazyCodecCache<>();
final JSONCodecFactory lazy = factorySupplier.apply(key, lazyCache);
}
// Weak keys to retire the entry when SchemaContext goes away
- private final LoadingCache<SchemaContext, JSONCodecFactory> precomputed;
+ private final LoadingCache<EffectiveModelContext, JSONCodecFactory> precomputed;
// Weak keys to retire the entry when SchemaContext goes away and to force identity-based lookup
- private final LoadingCache<SchemaContext, JSONCodecFactory> shared;
+ private final LoadingCache<EffectiveModelContext, JSONCodecFactory> shared;
JSONCodecFactorySupplier() {
precomputed = CacheBuilder.newBuilder().weakKeys().build(new EagerCacheLoader(this::createFactory));
- shared = CacheBuilder.newBuilder().weakKeys().build(new CacheLoader<SchemaContext, JSONCodecFactory>() {
+ shared = CacheBuilder.newBuilder().weakKeys().build(new CacheLoader<EffectiveModelContext, JSONCodecFactory>() {
@Override
- public JSONCodecFactory load(final SchemaContext key) {
+ public JSONCodecFactory load(final EffectiveModelContext key) {
return createFactory(key, new SharedCodecCache<>());
}
});
* <p>
* Choosing this implementation is appropriate when the memory overhead of keeping a full codec tree is not as
* great a concern as predictable performance. When compared to the implementation returned by
- * {@link #getShared(SchemaContext)}, this implementation is expected to offer higher performance and have lower
- * peak memory footprint when most of the SchemaContext is actually in use.
+ * {@link #getShared(EffectiveModelContext)}, this implementation is expected to offer higher performance and have
+ * lower peak memory footprint when most of the SchemaContext is actually in use.
*
* <p>
* For call sites which do not want to pay the CPU cost of pre-computing this implementation, but still would like
* to use it if is available (by being populated by some other caller), you can use
- * {@link #getPrecomputedIfAvailable(SchemaContext)}.
+ * {@link #getPrecomputedIfAvailable(EffectiveModelContext)}.
*
* @param context SchemaContext instance
* @return A sharable {@link JSONCodecFactory}
* @throws NullPointerException if context is null
*/
- public @NonNull JSONCodecFactory getPrecomputed(final @NonNull SchemaContext context) {
+ public @NonNull JSONCodecFactory getPrecomputed(final @NonNull EffectiveModelContext context) {
return verifyNotNull(precomputed.getUnchecked(context));
}
/**
* Get a thread-safe, eagerly-caching {@link JSONCodecFactory} for a SchemaContext, if it is available. This
- * method is a non-blocking equivalent of {@link #getPrecomputed(SchemaContext)} for use in code paths where
+ * method is a non-blocking equivalent of {@link #getPrecomputed(EffectiveModelContext)} for use in code paths where
* the potential of having to pre-compute the implementation is not acceptable. One such scenario is when the
* code base wants to opportunistically take advantage of pre-computed version, but is okay with a fallback to
* a different implementation.
* @return A sharable {@link JSONCodecFactory}, or absent if such an implementation is not available.
* @throws NullPointerException if context is null
*/
- public @NonNull Optional<JSONCodecFactory> getPrecomputedIfAvailable(final @NonNull SchemaContext context) {
+ public @NonNull Optional<JSONCodecFactory> getPrecomputedIfAvailable(final @NonNull EffectiveModelContext context) {
return Optional.ofNullable(precomputed.getIfPresent(context));
}
/**
* Get a thread-safe, lazily-caching {@link JSONCodecFactory} for a SchemaContext. This method can, and will,
- * return the same instance as long as the associated SchemaContext is present or the factory is not invalidated
- * by memory pressure. Returned object can be safely used by multiple threads concurrently.
+ * return the same instance as long as the associated EffectiveModelContext is present or the factory is not
+ * invalidated by memory pressure. Returned object can be safely used by multiple threads concurrently.
*
* <p>
* Choosing this implementation is a safe default, as it will not incur prohibitive blocking, nor will it tie up
* @return A sharable {@link JSONCodecFactory}
* @throws NullPointerException if context is null
*/
- public @NonNull JSONCodecFactory getShared(final @NonNull SchemaContext context) {
+ public @NonNull JSONCodecFactory getShared(final @NonNull EffectiveModelContext context) {
return verifyNotNull(shared.getUnchecked(context));
}
* @return A non-sharable {@link JSONCodecFactory}
* @throws NullPointerException if context is null
*/
- public @NonNull JSONCodecFactory createLazy(final @NonNull SchemaContext context) {
+ public @NonNull JSONCodecFactory createLazy(final @NonNull EffectiveModelContext context) {
return createFactory(context, new LazyCodecCache<>());
}
/**
- * Create a simplistic, thread-safe {@link JSONCodecFactory} for a {@link SchemaContext}. This method will return
- * distinct objects every time it is invoked. Returned object may be use from multiple threads concurrently.
+ * Create a simplistic, thread-safe {@link JSONCodecFactory} for a {@link EffectiveModelContext}. This method will
+ * return distinct objects every time it is invoked. Returned object may be use from multiple threads concurrently.
*
* <p>
* This implementation exists mostly for completeness only, as it does not perform any caching at all and each codec
* @return A non-sharable {@link JSONCodecFactory}
* @throws NullPointerException if context is null.
*/
- public @NonNull JSONCodecFactory createSimple(final @NonNull SchemaContext context) {
+ public @NonNull JSONCodecFactory createSimple(final @NonNull EffectiveModelContext context) {
return createFactory(context, NoopCodecCache.getInstance());
}
- abstract @NonNull JSONCodecFactory createFactory(SchemaContext context, CodecCache<JSONCodec<?>> cache);
+ abstract @NonNull JSONCodecFactory createFactory(EffectiveModelContext context, CodecCache<JSONCodec<?>> cache);
}
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
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.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypedDataSchemaNode;
*/
public static NormalizedNodeStreamWriter createExclusiveWriter(final JSONCodecFactory codecFactory,
final SchemaPath path, final URI initialNs, final JsonWriter jsonWriter) {
- return new Exclusive(codecFactory, SchemaTracker.create(codecFactory.getSchemaContext(), path), jsonWriter,
- new JSONStreamWriterExclusiveRootContext(initialNs));
+ return new Exclusive(codecFactory, SchemaTracker.create(codecFactory.getEffectiveModelContext(), path),
+ jsonWriter, new JSONStreamWriterExclusiveRootContext(initialNs));
}
/**
*/
public static NormalizedNodeStreamWriter createNestedWriter(final JSONCodecFactory codecFactory,
final SchemaPath path, final URI initialNs, final JsonWriter jsonWriter) {
- return new Nested(codecFactory, SchemaTracker.create(codecFactory.getSchemaContext(), path), jsonWriter,
+ return new Nested(codecFactory, SchemaTracker.create(codecFactory.getEffectiveModelContext(), path), jsonWriter,
new JSONStreamWriterSharedRootContext(initialNs));
}
@Override
public void startLeafNode(final NodeIdentifier name) throws IOException {
tracker.startLeafNode(name);
- context.emittingChild(codecs.getSchemaContext(), writer);
- context.writeChildJsonIdentifier(codecs.getSchemaContext(), writer, name.getNodeType());
+ context.emittingChild(codecs.getEffectiveModelContext(), writer);
+ context.writeChildJsonIdentifier(codecs.getEffectiveModelContext(), writer, name.getNodeType());
}
@Override
@Override
public void startLeafSetEntryNode(final NodeWithValue<?> name) throws IOException {
tracker.startLeafSetEntryNode(name);
- context.emittingChild(codecs.getSchemaContext(), writer);
+ context.emittingChild(codecs.getEffectiveModelContext(), writer);
}
@Override
public final boolean startAnydataNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
if (NormalizedAnydata.class.isAssignableFrom(objectModel)) {
tracker.startAnydataNode(name);
- context.emittingChild(codecs.getSchemaContext(), writer);
- context.writeChildJsonIdentifier(codecs.getSchemaContext(), writer, name.getNodeType());
+ context.emittingChild(codecs.getEffectiveModelContext(), writer);
+ context.writeChildJsonIdentifier(codecs.getEffectiveModelContext(), writer, name.getNodeType());
return true;
}
@Override
public final NormalizedNodeStreamWriter startMountPoint(final MountPointIdentifier mountId,
final MountPointContext mountCtx) throws IOException {
- final SchemaContext ctx = mountCtx.getSchemaContext();
+ final EffectiveModelContext ctx = mountCtx.getEffectiveModelContext();
return new Nested(codecs.rebaseTo(ctx), SchemaTracker.create(ctx), writer,
new JSONStreamWriterSharedRootContext(context.getNamespace()));
}
public final boolean startAnyxmlNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
if (DOMSource.class.isAssignableFrom(objectModel)) {
tracker.startAnyxmlNode(name);
- context.emittingChild(codecs.getSchemaContext(), writer);
- context.writeChildJsonIdentifier(codecs.getSchemaContext(), writer, name.getNodeType());
+ context.emittingChild(codecs.getEffectiveModelContext(), writer);
+ context.writeChildJsonIdentifier(codecs.getEffectiveModelContext(), writer, name.getNodeType());
return true;
}
return false;
@Override
public final void endNode() throws IOException {
tracker.endNode();
- context = context.endNode(codecs.getSchemaContext(), writer);
+ context = context.endNode(codecs.getEffectiveModelContext(), writer);
}
@Override
throw new IOException("Unexpected root context " + context);
}
- context.endNode(codecs.getSchemaContext(), writer);
+ context.endNode(codecs.getEffectiveModelContext(), writer);
writer.close();
}
}
private void writeNormalizedAnydata(final NormalizedAnydata anydata) throws IOException {
- anydata.writeTo(JSONNormalizedNodeStreamWriter.createNestedWriter(codecs.rebaseTo(anydata.getSchemaContext()),
+ anydata.writeTo(JSONNormalizedNodeStreamWriter.createNestedWriter(
+ codecs.rebaseTo(anydata.getEffectiveModelContext()),
new SingleChildDataNodeContainer(anydata.getContextNode()), context.getNamespace(), writer));
}
import org.eclipse.jdt.annotation.NonNull;
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;
/**
* Abstract base class for a single level of {@link JSONNormalizedNodeStreamWriter} recursion. Provides the base API
* @param qname Namespace/name tuple
* @throws IOException when the writer reports it
*/
- final void writeChildJsonIdentifier(final SchemaContext schema, final JsonWriter writer, final QName qname)
+ final void writeChildJsonIdentifier(final EffectiveModelContext schema, final JsonWriter writer, final QName qname)
throws IOException {
final StringBuilder sb = new StringBuilder();
* @param qname Namespace/name tuple
* @throws IOException when the writer reports it
*/
- protected final void writeMyJsonIdentifier(final SchemaContext schema, final JsonWriter writer, final QName qname)
- throws IOException {
+ protected final void writeMyJsonIdentifier(final EffectiveModelContext schema, final JsonWriter writer,
+ final QName qname) throws IOException {
parent.writeChildJsonIdentifier(schema, writer, qname);
}
* @param writer Output writer
* @throws IOException when the writer reports it
*/
- protected abstract void emitStart(SchemaContext schema, JsonWriter writer) throws IOException;
+ protected abstract void emitStart(EffectiveModelContext schema, JsonWriter writer) throws IOException;
/**
* Emit the end of an element.
*/
protected abstract void emitEnd(JsonWriter writer) throws IOException;
- private void emitMyself(final SchemaContext schema, final JsonWriter writer) throws IOException {
+ private void emitMyself(final EffectiveModelContext schema, final JsonWriter writer) throws IOException {
if (!emittedMyself) {
if (parent != null) {
parent.emitMyself(schema, writer);
* @param writer Output writer
* @throws IOException when writer reports it
*/
- final void emittingChild(final SchemaContext schema, final JsonWriter writer) throws IOException {
+ final void emittingChild(final EffectiveModelContext schema, final JsonWriter writer) throws IOException {
checkState(!inChild, "Duplicate child encountered");
emitMyself(schema, writer);
inChild = true;
* @throws IOException when writer reports it
* @throws IllegalArgumentException if this node cannot be ended (e.g. root)
*/
- final JSONStreamWriterContext endNode(final SchemaContext schema, final JsonWriter writer) throws IOException {
+ final JSONStreamWriterContext endNode(final EffectiveModelContext schema, final JsonWriter writer)
+ throws IOException {
if (inChild) {
inChild = false;
return this;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.net.URI;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
final class JSONStreamWriterExclusiveRootContext extends JSONStreamWriterRootContext {
JSONStreamWriterExclusiveRootContext(final URI namespace) {
}
@Override
- protected void emitStart(final SchemaContext schema, final JsonWriter writer) throws IOException {
+ protected void emitStart(final EffectiveModelContext schema, final JsonWriter writer) throws IOException {
writer.beginObject();
}
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
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;
/**
* A single recursion level of {@link JSONNormalizedNodeStreamWriter} representing
}
@Override
- protected void emitStart(final SchemaContext schema, final JsonWriter writer) throws IOException {
+ protected void emitStart(final EffectiveModelContext schema, final JsonWriter writer) throws IOException {
writeMyJsonIdentifier(schema, writer, getQName());
writer.beginArray();
}
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
/**
* A recursion level of {@link JSONNormalizedNodeStreamWriter}, which represents
}
@Override
- protected void emitStart(final SchemaContext schema, final JsonWriter writer) throws IOException {
+ protected void emitStart(final EffectiveModelContext schema, final JsonWriter writer) throws IOException {
writeMyJsonIdentifier(schema, writer, getQName());
super.emitStart(schema, writer);
}
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
/**
* A recursion level of {@link JSONNormalizedNodeStreamWriter}, which represents
}
@Override
- protected void emitStart(final SchemaContext schema, final JsonWriter writer) throws IOException {
+ protected void emitStart(final EffectiveModelContext schema, final JsonWriter writer) throws IOException {
writer.beginObject();
}
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.net.URI;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
/**
* Abstract class tracking a virtual level of {@link JSONNormalizedNodeStreamWriter}
}
@Override
- protected void emitStart(final SchemaContext schema, final JsonWriter writer) throws IOException {
+ protected void emitStart(final EffectiveModelContext schema, final JsonWriter writer) throws IOException {
// No-op
}
}
\ No newline at end of file
*/
public static @NonNull JsonParserStream create(final @NonNull NormalizedNodeStreamWriter writer,
final @NonNull JSONCodecFactory codecFactory) {
- return new JsonParserStream(writer, codecFactory, codecFactory.getSchemaContext(), false);
+ return new JsonParserStream(writer, codecFactory, codecFactory.getEffectiveModelContext(), false);
}
/**
*/
public static @NonNull JsonParserStream createLenient(final @NonNull NormalizedNodeStreamWriter writer,
final @NonNull JSONCodecFactory codecFactory) {
- return new JsonParserStream(writer, codecFactory, codecFactory.getSchemaContext(), true);
+ return new JsonParserStream(writer, codecFactory, codecFactory.getEffectiveModelContext(), true);
}
/**
moduleNamePart = childName.substring(0, lastIndexOfColon);
nodeNamePart = childName.substring(lastIndexOfColon + 1);
- final Iterator<? extends Module> m = codecs.getSchemaContext().findModules(moduleNamePart).iterator();
+ final Iterator<? extends Module> m = codecs.getEffectiveModelContext().findModules(moduleNamePart)
+ .iterator();
namespace = m.hasNext() ? m.next().getNamespace() : null;
} else {
nodeNamePart = childName;
for (final URI potentialUri : potentialUris) {
builder.append('\n');
//FIXME how to get information about revision from JSON input? currently first available is used.
- builder.append(codecs.getSchemaContext().findModules(potentialUri).iterator().next().getName());
+ builder.append(codecs.getEffectiveModelContext().findModules(potentialUri).iterator().next().getName());
}
return builder.toString();
}
import org.opendaylight.yangtools.yang.data.impl.codec.AbstractIntegerStringCodec;
import org.opendaylight.yangtools.yang.data.impl.codec.DecimalStringCodec;
import org.opendaylight.yangtools.yang.data.util.codec.CodecCache;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
final class Lhotka02JSONCodecFactory extends JSONCodecFactory {
private final JSONInstanceIdentifierCodec iidCodec;
- Lhotka02JSONCodecFactory(final SchemaContext context, final CodecCache<JSONCodec<?>> cache) {
+ Lhotka02JSONCodecFactory(final EffectiveModelContext context, final CodecCache<JSONCodec<?>> cache) {
super(context, cache);
iidCodec = new Lhotka02JSONInstanceIdentifierCodec(context, this);
}
}
@Override
- Lhotka02JSONCodecFactory rebaseTo(final SchemaContext newSchemaContext, final CodecCache<JSONCodec<?>> newCache) {
+ Lhotka02JSONCodecFactory rebaseTo(final EffectiveModelContext newSchemaContext,
+ final CodecCache<JSONCodec<?>> newCache) {
return new Lhotka02JSONCodecFactory(newSchemaContext, newCache);
}
import org.opendaylight.yangtools.yang.data.impl.codec.AbstractIntegerStringCodec;
import org.opendaylight.yangtools.yang.data.impl.codec.DecimalStringCodec;
import org.opendaylight.yangtools.yang.data.util.codec.CodecCache;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
final class RFC7951JSONCodecFactory extends JSONCodecFactory {
private final RFC7951JSONInstanceIdentifierCodec iidCodec;
- RFC7951JSONCodecFactory(final SchemaContext context, final CodecCache<JSONCodec<?>> cache) {
+ RFC7951JSONCodecFactory(final EffectiveModelContext context, final CodecCache<JSONCodec<?>> cache) {
super(context, cache);
iidCodec = new RFC7951JSONInstanceIdentifierCodec(context, this);
}
}
@Override
- JSONCodecFactory rebaseTo(final SchemaContext newSchemaContext, final CodecCache<JSONCodec<?>> newCache) {
+ JSONCodecFactory rebaseTo(final EffectiveModelContext newSchemaContext, final CodecCache<JSONCodec<?>> newCache) {
return new RFC7951JSONCodecFactory(newSchemaContext, newCache);
}
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
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.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
+ " \"yt1027:uint64\": 1\n"
+ "}";
- static SchemaContext SCHEMA_CONTEXT;
+ static EffectiveModelContext SCHEMA_CONTEXT;
private static DecimalTypeDefinition DECIMAL_TYPE;
private static Int64TypeDefinition INT64_TYPE;
private static Uint64TypeDefinition UINT64_TYPE;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
-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 Bug4501Test {
- private static SchemaContext schemaContext;
+ private static EffectiveModelContext schemaContext;
@BeforeClass
public static void initialization() {
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
-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 Bug4969Test {
@Test
public void newParserLeafRefTest() throws IOException, URISyntaxException {
- SchemaContext context = YangParserTestUtils.parseYangResourceDirectory("/bug-4969/yang");
+ EffectiveModelContext context = YangParserTestUtils.parseYangResourceDirectory("/bug-4969/yang");
assertNotNull(context);
verifyNormalizedNodeResult(context);
}
- private static void verifyNormalizedNodeResult(final SchemaContext context) throws IOException, URISyntaxException {
+ private static void verifyNormalizedNodeResult(final EffectiveModelContext context) throws IOException,
+ URISyntaxException {
final String inputJson = TestUtils.loadTextFile("/bug-4969/json/foo.json");
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
@Test
public void newParserLeafRefTest2() throws URISyntaxException, IOException {
- SchemaContext context = YangParserTestUtils.parseYangResourceDirectory("/leafref/yang");
+ EffectiveModelContext context = YangParserTestUtils.parseYangResourceDirectory("/leafref/yang");
assertNotNull(context);
parseJsonToNormalizedNodes(context);
}
- private static void parseJsonToNormalizedNodes(final SchemaContext context) throws IOException, URISyntaxException {
+ private static void parseJsonToNormalizedNodes(final EffectiveModelContext context) throws IOException,
+ URISyntaxException {
final String inputJson = TestUtils.loadTextFile("/leafref/json/data.json");
final NormalizedNodeResult result = new NormalizedNodeResult();
final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
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.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
private static final QNameModule FOO_MODULE = QNameModule.create(URI.create("foo"), Revision.of("2015-11-05"));
private static final QName ROOT_QNAME = QName.create(FOO_MODULE, "root");
private static final QName IP_ADDRESS_QNAME = QName.create(FOO_MODULE, "ip-address");
- private static SchemaContext schemaContext;
+ private static EffectiveModelContext schemaContext;
@BeforeClass
public static void init() {
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
-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 Bug6112Test {
- private static SchemaContext schemaContext;
+ private static EffectiveModelContext schemaContext;
@BeforeClass
public static void initialization() {
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.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
@Test
public void test() throws Exception {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResource("/bug7246/yang/rpc-test.yang");
+ final EffectiveModelContext schemaContext =
+ YangParserTestUtils.parseYangResource("/bug7246/yang/rpc-test.yang");
final JsonParser parser = new JsonParser();
final JsonElement expextedJson = parser
.parse(new FileReader(new File(getClass().getResource("/bug7246/json/expected-output.json").toURI())));
return QName.create(NS, localName);
}
- private static String normalizedNodeToJsonStreamTransformation(final SchemaContext schemaContext,
+ private static String normalizedNodeToJsonStreamTransformation(final EffectiveModelContext schemaContext,
final SchemaPath path, final Writer writer, final NormalizedNode<?, ?> inputStructure)
throws IOException {
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
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.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
.node(QName.create(BARMOD, "bar-leaf"))
.build();
- private static SchemaContext FULL_SCHEMA_CONTEXT;
+ private static EffectiveModelContext FULL_SCHEMA_CONTEXT;
@BeforeClass
public static void init() {
@Test
public void testInstanceIdentifierPathWithEmptyListKey() throws IOException, URISyntaxException {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResource("/bug8083/yang/baz.yang");
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResource("/bug8083/yang/baz.yang");
final String inputJson = loadTextFile("/bug8083/json/baz.json");
// deserialization
@Test
public void testInstanceIdentifierPathWithIdentityrefListKey() throws IOException, URISyntaxException {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResource("/bug8083/yang/zab.yang");
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResource("/bug8083/yang/zab.yang");
final String inputJson = loadTextFile("/bug8083/json/zab.json");
// deserialization
@Test
public void testInstanceIdentifierPathWithInstanceIdentifierListKey() throws IOException, URISyntaxException {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResource("/bug8083/yang/foobar.yang");
+ final EffectiveModelContext schemaContext = YangParserTestUtils.parseYangResource("/bug8083/yang/foobar.yang");
final String inputJson = loadTextFile("/bug8083/json/foobar.json");
// deserialization
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public final class TestUtils {
xmlParser.parse(reader);
}
- static String normalizedNodesToJsonString(final NormalizedNode<?, ?> data, final SchemaContext schemaContext,
- final SchemaPath rootPath) throws IOException {
+ static String normalizedNodesToJsonString(final NormalizedNode<?, ?> data,
+ final EffectiveModelContext schemaContext, final SchemaPath rootPath) throws IOException {
final Writer writer = new StringWriter();
final NormalizedNodeStreamWriter jsonStream = JSONNormalizedNodeStreamWriter.createExclusiveWriter(
JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02.getShared(schemaContext), rootPath, null,
final XmlParserStream xmlParser;
try {
- xmlParser = XmlParserStream.create(writer, mountCtx, mountCtx.getSchemaContext());
+ xmlParser = XmlParserStream.create(writer, mountCtx, mountCtx.getEffectiveModelContext());
} catch (IllegalArgumentException e) {
throw new IOException("Failed to instantiate XML parser", e);
}
private final MountPointContext mountCtx;
private XmlCodecFactory(final MountPointContext mountCtx) {
- super(mountCtx.getSchemaContext(), new SharedCodecCache<>());
+ super(mountCtx.getEffectiveModelContext(), new SharedCodecCache<>());
this.mountCtx = requireNonNull(mountCtx);
}
@Override
protected XmlCodec<?> identityRefCodec(final IdentityrefTypeDefinition type, final QNameModule module) {
- return new IdentityrefXmlCodec(getSchemaContext(), module);
+ return new IdentityrefXmlCodec(getEffectiveModelContext(), module);
}
@Override
protected XmlCodec<?> instanceIdentifierCodec(final InstanceIdentifierTypeDefinition type) {
- return new XmlStringInstanceIdentifierCodec(getSchemaContext(), this);
+ return new XmlStringInstanceIdentifierCodec(getEffectiveModelContext(), this);
}
@Override
if (optModule.isPresent()) {
final QName qname = QName.create(optModule.get(), localName);
final Optional<AnnotationSchemaNode> optAnnotation = AnnotationSchemaNode.find(
- codecs.getSchemaContext(), qname);
+ codecs.getEffectiveModelContext(), qname);
if (optAnnotation.isPresent()) {
final AnnotationSchemaNode schema = optAnnotation.get();
final Object value = codecs.codecFor(schema).parseValue(in.getNamespaceContext(), attrValue);
private Optional<QNameModule> resolveXmlNamespace(final String xmlNamespace) {
return resolvedNamespaces.computeIfAbsent(xmlNamespace, nsUri -> {
- final Iterator<? extends Module> it = codecs.getSchemaContext().findModules(URI.create(nsUri)).iterator();
+ final Iterator<? extends Module> it = codecs.getEffectiveModelContext().findModules(URI.create(nsUri))
+ .iterator();
return it.hasNext() ? Optional.of(it.next().getQNameModule()) : Optional.empty();
});
}
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;
final class XmlStringInstanceIdentifierCodec extends AbstractModuleStringInstanceIdentifierCodec
implements XmlCodec<YangInstanceIdentifier> {
private final @NonNull DataSchemaContextTree dataContextTree;
private final @NonNull XmlCodecFactory codecFactory;
- private final @NonNull SchemaContext context;
+ private final @NonNull EffectiveModelContext context;
- XmlStringInstanceIdentifierCodec(final SchemaContext context, final XmlCodecFactory xmlCodecFactory) {
+ XmlStringInstanceIdentifierCodec(final EffectiveModelContext context, final XmlCodecFactory xmlCodecFactory) {
this.context = requireNonNull(context);
this.dataContextTree = DataSchemaContextTree.from(context);
this.codecFactory = requireNonNull(xmlCodecFactory);
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedAnydata;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.util.AbstractSchemaContextProvider;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.util.AbstractEffectiveModelContextProvider;
@Beta
@NonNullByDefault
-public class ImmutableNormalizedAnydata extends AbstractSchemaContextProvider implements NormalizedAnydata {
+public class ImmutableNormalizedAnydata extends AbstractEffectiveModelContextProvider implements NormalizedAnydata {
private final DataSchemaNode contextNode;
private final NormalizedNode<?, ?> data;
- public ImmutableNormalizedAnydata(final SchemaContext schemaContext, final DataSchemaNode contextNode,
+ public ImmutableNormalizedAnydata(final EffectiveModelContext schemaContext, final DataSchemaNode contextNode,
final NormalizedNode<?, ?> data) {
super(schemaContext);
this.contextNode = requireNonNull(contextNode);
import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
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.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.TypeAware;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnknownTypeDefinition;
-import org.opendaylight.yangtools.yang.model.util.AbstractSchemaContextProvider;
+import org.opendaylight.yangtools.yang.model.util.AbstractEffectiveModelContextProvider;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @param <T> Codec type
* @author Robert Varga
*/
-public abstract class AbstractCodecFactory<T extends TypeAwareCodec<?, ?, ?>> extends AbstractSchemaContextProvider {
+public abstract class AbstractCodecFactory<T extends TypeAwareCodec<?, ?, ?>>
+ extends AbstractEffectiveModelContextProvider {
private static final Logger LOG = LoggerFactory.getLogger(AbstractCodecFactory.class);
private final @NonNull CodecCache<T> cache;
- protected AbstractCodecFactory(final @NonNull SchemaContext schemaContext, final @NonNull CodecCache<T> cache) {
+ protected AbstractCodecFactory(final @NonNull EffectiveModelContext schemaContext,
+ final @NonNull CodecCache<T> cache) {
super(schemaContext);
this.cache = requireNonNull(cache);
}
return createComplexUnion(schema, (UnionTypeDefinition) type);
} else if (type instanceof LeafrefTypeDefinition) {
final TypeDefinition<?> target = SchemaContextUtil.getBaseTypeForLeafRef((LeafrefTypeDefinition) type,
- getSchemaContext(), schema);
+ getEffectiveModelContext(), schema);
verifyNotNull(target, "Unable to find base type for leafref node %s type %s.", schema, target);
final T ret = getSimpleCodecFor(target);
Code Review / yangtools.git / commitdiff