final YangInstanceIdentifier parentPath = domPath.getParent();
if (parentPath != null && !parentPath.isEmpty()) {
final NormalizedNode<?, ?> parentNode = ImmutableNodes.fromInstanceId(
- serializer.getRuntimeContext().getSchemaContext(), parentPath);
+ serializer.getRuntimeContext().getEffectiveModelContext(), parentPath);
getDelegate().merge(store, YangInstanceIdentifier.create(parentNode.getIdentifier()), parentNode);
}
}
private Module getModule(final Class<?> modeledClass) {
final QNameModule moduleName = BindingReflections.getQNameModule(modeledClass);
final BindingRuntimeContext localRuntimeContext = getRuntimeContext();
- final Module module = localRuntimeContext.getSchemaContext().findModule(moduleName).orElse(null);
+ final Module module = localRuntimeContext.getEffectiveModelContext().findModule(moduleName).orElse(null);
if (module != null) {
return module;
}
return addPostponedOpAndWait(new FutureSchemaPredicate() {
@Override
public boolean test(final BindingRuntimeContext input) {
- return input.getSchemaContext().findModule(module).isPresent();
+ return input.getEffectiveModelContext().findModule(module).isPresent();
}
});
}
import org.opendaylight.mdsal.dom.spi.store.DOMStore;
import org.opendaylight.mdsal.dom.store.inmemory.InMemoryDOMDataStore;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
@Beta
public class BindingTestContext implements AutoCloseable {
mockSchemaService.changeSchema(BindingRuntimeHelpers.createEffectiveModel(moduleInfos));
}
- public SchemaContext getContext() {
- return mockSchemaService.getSchemaContext();
+ public EffectiveModelContext getContext() {
+ return mockSchemaService.getEffectiveModelContext();
}
public void start() {
final Class<?> valueType = method.getReturnType();
final IllegalArgumentCodec<Object, Object> codec = getCodec(valueType, leafSchema.getType());
valueNode = LeafNodeCodecContext.of(leafSchema, codec, method.getName(), valueType,
- context.getSchemaContext());
+ context.getEffectiveModelContext());
} else if (schema instanceof LeafListSchemaNode) {
final Optional<Type> optType = ClassLoaderUtils.getFirstGenericParameter(
method.getGenericReturnType());
@SuppressFBWarnings("BC_UNCONFIRMED_CAST")
public ContainerNode toNormalizedNodeRpcData(final DataContainer data) {
// FIXME: Should the cast to DataObject be necessary?
- return serializeDataObject((DataObject) data, (ctx, iface, domWriter) -> ctx.newRpcWriter(iface, domWriter));
+ return serializeDataObject((DataObject) data, @NonNull BindingNormalizedNodeWriterFactory::newRpcWriter);
}
@Override
private IllegalArgumentException childNullException(final QName child, final String message, final Object... args) {
final QNameModule module = child.getModule();
- if (!factory().getRuntimeContext().getSchemaContext().findModule(module).isPresent()) {
+ if (!factory().getRuntimeContext().getEffectiveModelContext().findModule(module).isPresent()) {
throw new MissingSchemaException("Module " + module + " is not present in current schema context.");
}
throw IncorrectNestingException.create(message, args);
}
static DataContainerCodecPrototype<SchemaContext> rootPrototype(final CodecContextFactory factory) {
- final SchemaContext schema = factory.getRuntimeContext().getSchemaContext();
+ final SchemaContext schema = factory.getRuntimeContext().getEffectiveModelContext();
final NodeIdentifier arg = NodeIdentifier.create(schema.getQName());
return new DataContainerCodecPrototype<>(DataRoot.class, arg, schema, factory);
}
import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
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.ModuleImport;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
private final @NonNull Class<T> bindingClass;
OfTypeObject(final LeafSchemaNode schema, final IllegalArgumentCodec<Object, Object> codec,
- final String getterName, final SchemaContext schemaContext, final Class<T> bindingClass) {
+ final String getterName, final EffectiveModelContext schemaContext, final Class<T> bindingClass) {
super(schema, codec, getterName, schemaContext);
this.bindingClass = requireNonNull(bindingClass);
}
}
LeafNodeCodecContext(final LeafSchemaNode schema, final IllegalArgumentCodec<Object, Object> codec,
- final String getterName, final SchemaContext schemaContext) {
+ final String getterName, final EffectiveModelContext schemaContext) {
super(schema, codec, getterName, createDefaultObject(schema, codec, schemaContext));
}
static LeafNodeCodecContext of(final LeafSchemaNode schema, final IllegalArgumentCodec<Object, Object> codec,
- final String getterName, final Class<?> valueType, final SchemaContext schemaContext) {
+ final String getterName, final Class<?> valueType, final EffectiveModelContext schemaContext) {
return TypeObject.class.isAssignableFrom(valueType)
? new OfTypeObject<>(schema, codec, getterName, schemaContext, valueType.asSubclass(TypeObject.class))
: new LeafNodeCodecContext(schema, codec, getterName, schemaContext);
private static Object createDefaultObject(final LeafSchemaNode schema,
final IllegalArgumentCodec<Object, Object> codec,
- final SchemaContext schemaContext) {
+ final EffectiveModelContext schemaContext) {
Optional<? extends Object> defaultValue = schema.getType().getDefaultValue();
TypeDefinition<?> type = schema.getType();
if (defaultValue.isPresent()) {
private static Object qnameDomValueFromString(final IllegalArgumentCodec<Object, Object> codec,
final DataSchemaNode schema, final String defaultValue,
- final SchemaContext schemaContext) {
+ final EffectiveModelContext schemaContext) {
int prefixEndIndex = defaultValue.indexOf(':');
QName qname;
if (prefixEndIndex != -1) {
import org.opendaylight.mdsal.binding.generator.util.BaseYangTypesProvider;
import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.concepts.IllegalArgumentCodec;
+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.PathExpression;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
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;
private static void addLeafrefValueCodec(final Class<?> unionCls, final UnionTypeDefinition unionType,
final BindingCodecContext bindingCodecContext, final Set<UnionValueOptionContext> values,
final TypeDefinition<?> subtype) throws NoSuchMethodException {
- final SchemaContext schemaContext = bindingCodecContext.getRuntimeContext().getSchemaContext();
+ final EffectiveModelContext schemaContext = bindingCodecContext.getRuntimeContext().getEffectiveModelContext();
final Module module = schemaContext.findModule(subtype.getQName().getModule()).get();
final PathExpression xpath = ((LeafrefTypeDefinition) subtype).getPathStatement();
// find schema node in schema context by xpath of leafref