import java.lang.reflect.Method;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.ActionSpec;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMActionResult;
import org.opendaylight.mdsal.dom.api.DOMActionService;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.RpcInput;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
return spec.type().getName() + "$Adapter{delegate=" + getDelegate() + "}";
}
break;
- case BindingMapping.ACTION_INVOKE_NAME:
+ case Naming.ACTION_INVOKE_NAME:
if (args.length == 2) {
final InstanceIdentifier<?> path = (InstanceIdentifier<?>) requireNonNull(args[0]);
checkArgument(!path.isWildcarded(), "Cannot invoke action on wildcard path %s", path);
import java.lang.reflect.Method;
import java.util.Set;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
final class ActionAdapterFilter implements InvocationHandler {
private final Set<DataTreeIdentifier<?>> nodes;
@Override
public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
- if (BindingMapping.ACTION_INVOKE_NAME.equals(method.getName()) && args.length == 2) {
+ if (Naming.ACTION_INVOKE_NAME.equals(method.getName()) && args.length == 2) {
final InstanceIdentifier<?> path = (InstanceIdentifier<?>) requireNonNull(args[0]);
checkState(nodes.contains(DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, path)),
"Cannot service %s", path);
import java.lang.invoke.MethodType;
import java.lang.reflect.Method;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.annotations.RoutingContext;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static @Nullable Method findGetValueMethod(final Class<?> type, final Class<?> returnType) {
final Method method;
try {
- method = type.getMethod(BindingMapping.SCALAR_TYPE_OBJECT_GET_VALUE_NAME);
+ method = type.getMethod(Naming.SCALAR_TYPE_OBJECT_GET_VALUE_NAME);
} catch (NoSuchMethodException e) {
LOG.warn("Value class {} does not comform to Binding Specification v1.", type, e);
return null;
import org.opendaylight.mdsal.binding.dom.codec.spi.ForwardingBindingDOMCodecServices;
import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.runtime.api.InputRuntimeType;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.RpcInput;
import org.opendaylight.yangtools.yang.binding.RpcService;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
try {
for (var rpcDef : module.getRpcs()) {
final var rpcName = rpcDef.getQName();
- ret.put(rpcName, key.getMethod(BindingMapping.getRpcMethodName(rpcName),
- runtimeContext.getRpcInput(rpcName)));
+ ret.put(rpcName, key.getMethod(Naming.getRpcMethodName(rpcName), runtimeContext.getRpcInput(rpcName)));
}
} catch (NoSuchMethodException e) {
throw new IllegalStateException("Rpc defined in model does not have representation in generated class.", e);
import static java.util.Objects.requireNonNull;
import java.lang.reflect.Method;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.yangtools.yang.binding.Rpc;
import org.opendaylight.yangtools.yang.binding.RpcInput;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
final class RpcAdapter<T extends Rpc<?, ?>> extends AbstractRpcAdapter {
private final RpcInvocationStrategy strategy;
}
try {
- invokeMethod = type.getMethod(BindingMapping.RPC_INVOKE_NAME, RpcInput.class);
+ invokeMethod = type.getMethod(Naming.RPC_INVOKE_NAME, RpcInput.class);
} catch (NoSuchMethodException e) {
throw new IllegalStateException("Failed to find invoke method in " + type, e);
}
import java.util.Map;
import java.util.Map.Entry;
import org.opendaylight.mdsal.binding.runtime.api.RpcRuntimeType;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.yangtools.yang.binding.RpcInput;
import org.opendaylight.yangtools.yang.binding.RpcService;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.model.api.stmt.RpcEffectiveStatement;
@Deprecated
.map(rpc -> {
final var rpcName = rpc.argument();
final var inputClz = runtimeContext.getRpcInput(rpcName);
- final var methodName = BindingMapping.getRpcMethodName(rpcName);
+ final var methodName = Naming.getRpcMethodName(rpcName);
final Method method;
try {
package org.opendaylight.mdsal.binding.dom.codec.spi;
import com.google.common.annotations.Beta;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
@Beta
}
public static String getGetterMethodName(final DataSchemaNode node) {
- return BindingMapping.getGetterMethodName(node.getQName());
+ return Naming.getGetterMethodName(node.getQName());
}
}
import java.util.TreeSet;
import java.util.concurrent.ExecutionException;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.yang.binding.BitsTypeObject;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
final Set<String> ctorArgs = new TreeSet<>();
for (Bit bit : rootType.getBits()) {
- final Method valueGetter = returnType.getMethod(BindingMapping.GETTER_PREFIX
- + BindingMapping.getClassName(bit.getName()));
+ final Method valueGetter = returnType.getMethod(Naming.GETTER_PREFIX
+ + Naming.getClassName(bit.getName()));
ctorArgs.add(bit.getName());
getters.put(bit.getName(), valueGetter);
}
import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeContext;
import org.opendaylight.mdsal.binding.runtime.api.CaseRuntimeType;
import org.opendaylight.mdsal.binding.runtime.api.ChoiceRuntimeType;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
checkArgument(DataContainer.class.isAssignableFrom(type), "Supplied type must be derived from DataContainer");
List<Class<? extends DataObject>> ret = new LinkedList<>();
for (Method method : type.getMethods()) {
- Optional<Class<? extends DataContainer>> entity = getYangModeledReturnType(method,
- BindingMapping.GETTER_PREFIX);
+ Optional<Class<? extends DataContainer>> entity = getYangModeledReturnType(method, Naming.GETTER_PREFIX);
if (entity.isPresent()) {
ret.add((Class<? extends DataObject>) entity.get());
}
import org.opendaylight.mdsal.binding.loader.BindingClassLoader;
import org.opendaylight.mdsal.binding.loader.BindingClassLoader.ClassGenerator;
import org.opendaylight.mdsal.binding.loader.BindingClassLoader.GeneratorResult;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return new Implementation.Simple(
// return Foo.bindingHashCode(this);
loadThis(),
- invokeMethod(bindingInterface, BindingMapping.BINDING_HASHCODE_NAME, bindingInterface),
+ invokeMethod(bindingInterface, Naming.BINDING_HASHCODE_NAME, bindingInterface),
MethodReturn.INTEGER);
}
// return Foo.bindingEquals(this, obj);
loadThis(),
FIRST_ARG_REF,
- invokeMethod(bindingInterface, BindingMapping.BINDING_EQUALS_NAME, bindingInterface, Object.class),
+ invokeMethod(bindingInterface, Naming.BINDING_EQUALS_NAME, bindingInterface, Object.class),
MethodReturn.INTEGER);
}
return new Implementation.Simple(
// return Foo.bindingToString(this);
loadThis(),
- invokeMethod(bindingInterface, BindingMapping.BINDING_TO_STRING_NAME, bindingInterface),
+ invokeMethod(bindingInterface, Naming.BINDING_TO_STRING_NAME, bindingInterface),
MethodReturn.REFERENCE);
}
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.loader.BindingClassLoader;
import org.opendaylight.mdsal.binding.loader.BindingClassLoader.ClassGenerator;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
/**
* Centralized registry of Java package names used by classes generated by codec components.
*/
EVENT_AWARE("org.opendaylight.yang.rt.v1.eia");
- private static final int PACKAGE_PREFIX_LENGTH = BindingMapping.PACKAGE_PREFIX.length();
+ private static final int PACKAGE_PREFIX_LENGTH = Naming.PACKAGE_PREFIX.length();
private String packagePrefix;
private @NonNull String createFQCN(final Class<?> bindingInterface) {
final var ifName = bindingInterface.getName();
- checkArgument(ifName.startsWith(BindingMapping.PACKAGE_PREFIX), "Unrecognized interface %s", bindingInterface);
+ checkArgument(ifName.startsWith(Naming.PACKAGE_PREFIX), "Unrecognized interface %s", bindingInterface);
return packagePrefix + ifName.substring(PACKAGE_PREFIX_LENGTH);
}
}
import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeContext;
import org.opendaylight.mdsal.binding.runtime.api.ChoiceRuntimeType;
import org.opendaylight.mdsal.binding.runtime.api.CompositeRuntimeType;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.yangtools.yang.binding.Augmentable;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.Item;
import org.opendaylight.yangtools.yang.binding.OpaqueObject;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
*/
// FIXME: MDSAL-780: replace use of this method
private static Map<Class<? extends DataContainer>, Method> getChildrenClassToMethod(final Class<?> type) {
- return getChildClassToMethod(type, BindingMapping.GETTER_PREFIX);
+ return getChildClassToMethod(type, Naming.GETTER_PREFIX);
}
// FIXME: MDSAL-780: replace use of this method
private static Map<Class<? extends DataContainer>, Method> getChildrenClassToNonnullMethod(final Class<?> type) {
- return getChildClassToMethod(type, BindingMapping.NONNULL_PREFIX);
+ return getChildClassToMethod(type, Naming.NONNULL_PREFIX);
}
// FIXME: MDSAL-780: replace use of this method
import java.lang.invoke.MethodType;
import java.util.concurrent.ExecutionException;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.yang.binding.ScalarTypeObject;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
/**
* Derived YANG types are just immutable value holders for simple value
@Override
public EncapsulatedValueCodec load(final Class<? extends ScalarTypeObject> key)
throws ReflectiveOperationException {
- final var method = key.getMethod(BindingMapping.SCALAR_TYPE_OBJECT_GET_VALUE_NAME);
+ final var method = key.getMethod(Naming.SCALAR_TYPE_OBJECT_GET_VALUE_NAME);
final var lookup = MethodHandles.publicLookup();
final var retType = method.getReturnType();
return new EncapsulatedValueCodec(lookup.findConstructor(key,
import java.util.List;
import java.util.Map;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.util.ImmutableOffsetMap;
import org.opendaylight.yangtools.util.ImmutableOffsetMapTemplate;
import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.model.api.stmt.KeyEffectiveStatement;
*/
final var tmp = new ArrayList<>(keyDef);
// This is not terribly efficient but gets the job done
- tmp.sort(Comparator.comparing(leaf -> BindingMapping.getPropertyName(leaf.getLocalName())));
+ tmp.sort(Comparator.comparing(leaf -> Naming.getPropertyName(leaf.getLocalName())));
keysInBindingOrder = ImmutableList.copyOf(tmp.equals(List.copyOf(keyDef)) ? keyDef : tmp);
}
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingIdentityCodec;
import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeContext;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.yangtools.yang.binding.BaseIdentity;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.QName;
final class IdentityCodec extends AbstractValueCodec<QName, BaseIdentity> implements BindingIdentityCodec {
final var clazz = context.getIdentityClass(key);
final Field field;
try {
- field = clazz.getField(BindingMapping.VALUE_STATIC_FIELD_NAME);
+ field = clazz.getField(Naming.VALUE_STATIC_FIELD_NAME);
} catch (NoSuchFieldException e) {
- throw new LinkageError(clazz + " does not define required field "
- + BindingMapping.VALUE_STATIC_FIELD_NAME, e);
+ throw new LinkageError(clazz + " does not define required field " + Naming.VALUE_STATIC_FIELD_NAME,
+ e);
}
if (!Modifier.isStatic(field.getModifiers())) {
throw new LinkageError(field + " is not static");
package org.opendaylight.mdsal.binding.dom.codec.impl;
import static java.util.Objects.requireNonNull;
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.IDENTIFIABLE_KEY_NAME;
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.IDENTIFIABLE_KEY_NAME;
import java.lang.reflect.Method;
import java.util.List;
import org.opendaylight.mdsal.binding.runtime.api.DataRuntimeType;
import org.opendaylight.mdsal.binding.runtime.api.NotificationRuntimeType;
import org.opendaylight.mdsal.binding.runtime.api.RuntimeType;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.yangtools.util.ClassLoaderUtils;
import org.opendaylight.yangtools.yang.binding.Action;
import org.opendaylight.yangtools.yang.binding.Notification;
import org.opendaylight.yangtools.yang.binding.RpcInput;
import org.opendaylight.yangtools.yang.binding.RpcOutput;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
final QNameModule qnameModule = qname.getModule();
final Module module = context.getEffectiveModelContext().findModule(qnameModule)
.orElseThrow(() -> new IllegalArgumentException("Failed to find module for " + qnameModule));
- final String className = BindingMapping.getClassName(qname);
+ final String className = Naming.getClassName(qname);
for (final RpcDefinition potential : module.getRpcs()) {
final QName potentialQName = potential.getQName();
*
* FIXME: Rework this to have more precise logic regarding Binding Specification.
*/
- if (key.getSimpleName().equals(BindingMapping.getClassName(potentialQName) + className)) {
+ if (key.getSimpleName().equals(Naming.getClassName(potentialQName) + className)) {
final ContainerLike schema = getRpcDataSchema(potential, qname);
checkArgument(schema != null, "Schema for %s does not define input / output.", potentialQName);
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.runtime.api.RuntimeGeneratedUnion;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
final List<UnionValueOptionContext> values = new ArrayList<>(unionTypes.size());
final Iterator<String> it = unionProperties.iterator();
for (final TypeDefinition<?> subtype : unionTypes) {
- final String getterName = BindingMapping.GETTER_PREFIX + BindingMapping.toFirstUpper(it.next());
+ final String getterName = Naming.GETTER_PREFIX + Naming.toFirstUpper(it.next());
final Method valueGetter = unionCls.getMethod(getterName);
final Class<?> valueType = valueGetter.getReturnType();
final ValueCodec<Object, Object> codec = codecContext.getCodec(valueType, subtype);
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
import org.opendaylight.mdsal.binding.runtime.api.RuntimeType;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.AbstractQName;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AddedByUsesAware;
}
MethodSignatureBuilder constructGetter(final GeneratedTypeBuilderBase<?> builder, final Type returnType) {
- return constructGetter(builder, returnType, BindingMapping.getGetterMethodName(localName().getLocalName()));
+ return constructGetter(builder, returnType, Naming.getGetterMethodName(localName().getLocalName()));
}
final MethodSignatureBuilder constructGetter(final GeneratedTypeBuilderBase<?> builder,
}
final void constructRequireImpl(final GeneratedTypeBuilderBase<?> builder, final Type returnType) {
- constructGetter(builder, returnType, BindingMapping.getRequireMethodName(localName().getLocalName()))
+ constructGetter(builder, returnType, Naming.getRequireMethodName(localName().getLocalName()))
.setDefault(true)
.setMechanics(ValueMechanics.NONNULL);
}
import org.opendaylight.mdsal.binding.model.ri.generated.type.builder.AbstractEnumerationBuilder;
import org.opendaylight.mdsal.binding.model.ri.generated.type.builder.GeneratedPropertyBuilderImpl;
import org.opendaylight.mdsal.binding.runtime.api.RuntimeType;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.binding.RegexPatterns;
import org.opendaylight.yangtools.yang.binding.TypeObject;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.YangConstants;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
for (Bit bit : typedef.getBits()) {
final String name = bit.getName();
- GeneratedPropertyBuilder genPropertyBuilder = builder.addProperty(BindingMapping.getPropertyName(name));
+ GeneratedPropertyBuilder genPropertyBuilder = builder.addProperty(Naming.getPropertyName(name));
genPropertyBuilder.setReadOnly(true);
genPropertyBuilder.setReturnType(Types.primitiveBooleanType());
generatedType = subUnion;
} else if (TypeDefinitions.ENUMERATION.equals(subName)) {
final Enumeration subEnumeration = createEnumeration(builderFactory, definingStatement,
- typeName.createEnclosed(BindingMapping.getClassName(localName), "$"), module,
+ typeName.createEnclosed(Naming.getClassName(localName), "$"), module,
(EnumTypeDefinition) subType.getTypeDefinition());
builder.addEnumeration(subEnumeration);
generatedType = subEnumeration;
} else if (TypeDefinitions.BITS.equals(subName)) {
final GeneratedTransferObject subBits = createBits(builderFactory, definingStatement,
- typeName.createEnclosed(BindingMapping.getClassName(localName), "$"), module,
+ typeName.createEnclosed(Naming.getClassName(localName), "$"), module,
(BitsTypeDefinition) subType.getTypeDefinition(), isTypedef);
builder.addEnclosingTransferObject(subBits);
generatedType = subBits;
}
// ... otherwise generate this weird property name
- propSource = BindingMapping.getUnionLeafrefMemberName(builder.getName(),
- baseType.getName());
+ propSource = Naming.getUnionLeafrefMemberName(builder.getName(), baseType.getName());
}
}
BindingGeneratorUtil.getRestrictions(type.getTypeDefinition()), builderFactory);
}
- final String propName = BindingMapping.getPropertyName(propSource);
+ final String propName = Naming.getPropertyName(propSource);
typeProperties.add(propName);
if (builder.containsProperty(propName)) {
import java.util.List;
import java.util.Map.Entry;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.AbstractQName;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
}
@NonNull Member addSecondary(final InputGenerator memberGen, final Member primary) {
- return addMember(new SuffixSecondary(memberGen, primary, BindingMapping.RPC_INPUT_SUFFIX,
+ return addMember(new SuffixSecondary(memberGen, primary, Naming.RPC_INPUT_SUFFIX,
memberGen.statement().argument()));
}
@NonNull Member addSecondary(final OutputGenerator memberGen, final Member primary) {
- return addMember(new SuffixSecondary(memberGen, primary, BindingMapping.RPC_OUTPUT_SUFFIX,
+ return addMember(new SuffixSecondary(memberGen, primary, Naming.RPC_OUTPUT_SUFFIX,
memberGen.statement().argument()));
}
import org.opendaylight.mdsal.binding.runtime.api.AugmentRuntimeType;
import org.opendaylight.mdsal.binding.runtime.api.ContainerRuntimeType;
import org.opendaylight.mdsal.binding.runtime.api.RuntimeType;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.model.api.stmt.ContainerEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PresenceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
.setMechanics(ValueMechanics.NORMAL);
if (statement().findFirstEffectiveSubstatement(PresenceEffectiveStatement.class).isEmpty()) {
final MethodSignatureBuilder nonnull = builder
- .addMethod(BindingMapping.getNonnullMethodName(localName().getLocalName()))
+ .addMethod(Naming.getNonnullMethodName(localName().getLocalName()))
.setReturnType(returnType)
.setDefault(false);
annotateDeprecatedIfNecessary(nonnull);
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
import org.opendaylight.mdsal.binding.model.ri.BindingTypes;
import org.opendaylight.mdsal.binding.runtime.api.FeatureRuntimeType;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.yang.binding.YangFeature;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.model.api.stmt.FeatureEffectiveStatement;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
module.addQNameConstant(builder, localName());
// Constant implementation
- builder.addConstant(Type.of(builder), BindingMapping.VALUE_STATIC_FIELD_NAME, YangFeature.class);
+ builder.addConstant(Type.of(builder), Naming.VALUE_STATIC_FIELD_NAME, YangFeature.class);
builderFactory.addCodegenInformation(module, statement(), builder);
builder.setModuleName(module.statement().argument().getLocalName());
import org.opendaylight.mdsal.binding.model.ri.BindingTypes;
import org.opendaylight.mdsal.binding.model.ri.Types;
import org.opendaylight.mdsal.binding.model.ri.generated.type.builder.GeneratedPropertyBuilderImpl;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.yang.binding.DataContainer;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
@NonNull String createJavaPackage() {
final String parentPackage = getPackageParent().javaPackage();
final String myPackage = getMember().currentPackage();
- return BindingMapping.normalizePackageName(parentPackage + '.' + myPackage);
+ return Naming.normalizePackageName(parentPackage + '.' + myPackage);
}
final @NonNull JavaTypeName typeName() {
static final void addConcreteInterfaceMethods(final GeneratedTypeBuilder builder) {
defaultImplementedInterace(builder);
- builder.addMethod(BindingMapping.BINDING_HASHCODE_NAME)
+ builder.addMethod(Naming.BINDING_HASHCODE_NAME)
.setAccessModifier(AccessModifier.PUBLIC)
.setStatic(true)
.setReturnType(primitiveIntType());
- builder.addMethod(BindingMapping.BINDING_EQUALS_NAME)
+ builder.addMethod(Naming.BINDING_EQUALS_NAME)
.setAccessModifier(AccessModifier.PUBLIC)
.setStatic(true)
.setReturnType(primitiveBooleanType());
- builder.addMethod(BindingMapping.BINDING_TO_STRING_NAME)
+ builder.addMethod(Naming.BINDING_TO_STRING_NAME)
.setAccessModifier(AccessModifier.PUBLIC)
.setStatic(true)
.setReturnType(STRING);
private static MethodSignatureBuilder defineImplementedInterfaceMethod(final GeneratedTypeBuilder typeBuilder,
final Type classType) {
final MethodSignatureBuilder ret = typeBuilder
- .addMethod(BindingMapping.BINDING_CONTRACT_IMPLEMENTED_INTERFACE_NAME)
+ .addMethod(Naming.BINDING_CONTRACT_IMPLEMENTED_INTERFACE_NAME)
.setAccessModifier(AccessModifier.PUBLIC)
.setReturnType(classType(classType));
ret.addAnnotation(OVERRIDE_ANNOTATION);
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
import org.opendaylight.mdsal.binding.runtime.api.IdentityRuntimeType;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.yang.binding.BaseIdentity;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.model.api.stmt.BaseEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityEffectiveStatement;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
module.addQNameConstant(builder, localName());
// Constant implementation
- builder.addConstant(Type.of(builder), BindingMapping.VALUE_STATIC_FIELD_NAME, BaseIdentity.class);
+ builder.addConstant(Type.of(builder), Naming.VALUE_STATIC_FIELD_NAME, BaseIdentity.class);
builderFactory.addCodegenInformation(module, statement(), builder);
builder.setModuleName(module.statement().argument().getLocalName());
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
import org.opendaylight.mdsal.binding.model.ri.BindingTypes;
import org.opendaylight.mdsal.binding.runtime.api.KeyRuntimeType;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.stmt.KeyEffectiveStatement;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
@Override
Member createMember(final CollisionDomain domain) {
- return domain.addSecondary(this, listGen.getMember(), BindingMapping.KEY_SUFFIX);
+ return domain.addSecondary(this, listGen.getMember(), Naming.KEY_SUFFIX);
}
@Override
final QName qname = leafGen.statement().argument();
if (leafNames.contains(qname)) {
final var prop = builder
- .addProperty(BindingMapping.getPropertyName(qname.getLocalName()))
+ .addProperty(Naming.getPropertyName(qname.getLocalName()))
.setReturnType(leafGen.methodReturnType(builderFactory))
.setReadOnly(true);
import org.opendaylight.mdsal.binding.runtime.api.KeyRuntimeType;
import org.opendaylight.mdsal.binding.runtime.api.ListRuntimeType;
import org.opendaylight.mdsal.binding.runtime.api.RuntimeType;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.Ordering;
import org.opendaylight.yangtools.yang.model.api.stmt.KeyEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ListEffectiveStatement;
// Add yang.binding.Identifiable and its key() method
final GeneratedType keyType = keyGen.getGeneratedType(builderFactory);
builder.addImplementsType(identifiable(keyType));
- builder.addMethod(BindingMapping.IDENTIFIABLE_KEY_NAME)
+ builder.addMethod(Naming.IDENTIFIABLE_KEY_NAME)
.setReturnType(keyType)
.addAnnotation(OVERRIDE_ANNOTATION);
}
.setMechanics(ValueMechanics.NULLIFY_EMPTY);
final MethodSignatureBuilder nonnull = builder
- .addMethod(BindingMapping.getNonnullMethodName(localName().getLocalName()))
+ .addMethod(Naming.getNonnullMethodName(localName().getLocalName()))
.setReturnType(returnType)
.setDefault(true);
annotateDeprecatedIfNecessary(nonnull);
import org.opendaylight.mdsal.binding.runtime.api.AugmentRuntimeType;
import org.opendaylight.mdsal.binding.runtime.api.ModuleRuntimeType;
import org.opendaylight.mdsal.binding.runtime.api.RuntimeType;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.AbstractQName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
/**
* Note that for sake of simplicity of lookup and child mapping, this instance serves as the root for all child
* generators, but mapping to {@link CollisionDomain}s and their {@link Member}s is rather weird. This generator
- * actually produces one of <em>secondary</em> members, more precisely the {@link BindingMapping#DATA_ROOT_SUFFIX}
- * one. Counter-intuitively the other secondary members live as children of this generator. To support this we have
- * also have this field, which is actually the <em>primary</em> derived from the module's name.
+ * actually produces one of <em>secondary</em> members, more precisely the {@link Naming#DATA_ROOT_SUFFIX} one.
+ * Counter-intuitively the other secondary members live as children of this generator. To support this we also have
+ * this field, which is actually the <em>primary</em> derived from the module's name.
*/
private final Member prefixMember;
ModuleGenerator(final ModuleEffectiveStatement statement) {
super(statement);
- yangModuleInfo = JavaTypeName.create(javaPackage(), BindingMapping.MODULE_INFO_CLASS_NAME);
+ yangModuleInfo = JavaTypeName.create(javaPackage(), Naming.MODULE_INFO_CLASS_NAME);
prefixMember = domain().addPrefix(this, new ModuleNamingStrategy(statement.argument()));
}
@Override
String createJavaPackage() {
- return BindingMapping.getRootPackageName(statement().localQNameModule());
+ return Naming.getRootPackageName(statement().localQNameModule());
}
@Override
@Override
Member createMember(final CollisionDomain domain) {
- return domain.addSecondary(this, prefixMember, BindingMapping.DATA_ROOT_SUFFIX);
+ return domain.addSecondary(this, prefixMember, Naming.DATA_ROOT_SUFFIX);
}
@Override
}
void addQNameConstant(final GeneratedTypeBuilderBase<?> builder, final AbstractQName localName) {
- builder.addConstant(BindingTypes.QNAME, BindingMapping.QNAME_STATIC_FIELD_NAME,
+ builder.addConstant(BindingTypes.QNAME, Naming.QNAME_STATIC_FIELD_NAME,
Map.entry(yangModuleInfo, localName.getLocalName()));
}
// FIXME: use YangDataName
void addNameConstant(final GeneratedTypeBuilderBase<?> builder, final String templateName) {
- builder.addConstant(BindingTypes.YANG_DATA_NAME, BindingMapping.NAME_STATIC_FIELD_NAME,
+ builder.addConstant(BindingTypes.YANG_DATA_NAME, Naming.NAME_STATIC_FIELD_NAME,
Map.entry(yangModuleInfo, templateName));
}
import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
import org.opendaylight.mdsal.binding.model.ri.BindingTypes;
import org.opendaylight.mdsal.binding.model.ri.Types;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.stmt.NotificationEffectiveStatement;
@Override
String classSuffix() {
- return BindingMapping.NOTIFICATION_LISTENER_SUFFIX;
+ return Naming.NOTIFICATION_LISTENER_SUFFIX;
}
@Override
import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
import org.opendaylight.mdsal.binding.model.ri.BindingTypes;
import org.opendaylight.mdsal.binding.model.ri.Types;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.InputEffectiveStatement;
@Override
String classSuffix() {
- return BindingMapping.RPC_SERVICE_SUFFIX;
+ return Naming.RPC_SERVICE_SUFFIX;
}
@Override
final QName qname = rpc.argument();
// FIXME: this may still conflict in theory
- final MethodSignatureBuilder method = builder.addMethod(BindingMapping.getRpcMethodName(qname));
+ final MethodSignatureBuilder method = builder.addMethod(Naming.getRpcMethodName(qname));
method.addParameter(getChild(rpcGen, InputEffectiveStatement.class).getGeneratedType(builderFactory),
"input");
import com.google.common.base.MoreObjects.ToStringHelper;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
/**
* Naming strategy for {@code ietf-restconf:yang-data} template which has a generic string not matching YANG identifier.
private final String javaIdentifier;
YangDataNamingStrategy(final String templateName) {
- javaIdentifier = BindingMapping.mapYangDataName(templateName);
+ javaIdentifier = Naming.mapYangDataName(templateName);
}
@Override
import com.google.common.base.MoreObjects.ToStringHelper;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.AbstractQName;
/**
@Override
final String simpleClassName() {
- return BindingMapping.getClassName(rootName());
+ return Naming.getClassName(rootName());
}
@Override
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.MethodSignature;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class AugmentRelativeXPathTest {
MethodSignature getIfcKeyMethod = null;
for (final MethodSignature method : gtInterfaceMethods) {
- if (BindingMapping.IDENTIFIABLE_KEY_NAME.equals(method.getName())) {
+ if (Naming.IDENTIFIABLE_KEY_NAME.equals(method.getName())) {
getIfcKeyMethod = method;
break;
}
MethodSignature getTunnelKeyMethod = null;
for (MethodSignature method : tunnelMethods) {
- if (BindingMapping.IDENTIFIABLE_KEY_NAME.equals(method.getName())) {
+ if (Naming.IDENTIFIABLE_KEY_NAME.equals(method.getName())) {
getTunnelKeyMethod = method;
break;
}
import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.MethodSignature;
import org.opendaylight.mdsal.binding.model.ri.Types;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
assertNotNull("gtInterfaceMethods is null", gtInterfaceMethods);
MethodSignature getIfcKeyMethod = null;
for (final MethodSignature method : gtInterfaceMethods) {
- if (BindingMapping.IDENTIFIABLE_KEY_NAME.equals(method.getName())) {
+ if (Naming.IDENTIFIABLE_KEY_NAME.equals(method.getName())) {
getIfcKeyMethod = method;
break;
}
assertNotNull("Tunnel methods are null", tunnelMethods);
MethodSignature getTunnelKeyMethod = null;
for (MethodSignature method : tunnelMethods) {
- if (BindingMapping.IDENTIFIABLE_KEY_NAME.equals(method.getName())) {
+ if (Naming.IDENTIFIABLE_KEY_NAME.equals(method.getName())) {
getTunnelKeyMethod = method;
break;
}
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.MethodSignature;
import org.opendaylight.mdsal.binding.model.api.Type;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
MethodSignature getHigherLayerIf = null;
for (final MethodSignature method : gtIfcMethods) {
switch (method.getName()) {
- case BindingMapping.IDENTIFIABLE_KEY_NAME:
+ case Naming.IDENTIFIABLE_KEY_NAME:
getIfcKey = method;
break;
case "getHigherLayerIf":
assertNotNull(gtTunnelMethods);
MethodSignature getTunnelKey = null;
for (MethodSignature method : gtTunnelMethods) {
- if (BindingMapping.IDENTIFIABLE_KEY_NAME.equals(method.getName())) {
+ if (Naming.IDENTIFIABLE_KEY_NAME.equals(method.getName())) {
getTunnelKey = method;
}
}
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.MethodSignature;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class GeneratedTypesTest {
final List<MethodSignature> methods = genType.getMethodDefinitions();
for (final MethodSignature method : methods) {
switch (method.getName()) {
- case BindingMapping.IDENTIFIABLE_KEY_NAME:
+ case Naming.IDENTIFIABLE_KEY_NAME:
getSimpleListKeyMethodCount++;
getSimpleListKeyMethodReturnTypeName = method.getReturnType().getName();
break;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.MethodSignature;
import org.opendaylight.mdsal.binding.model.api.Type;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class Mdsal320Test {
assertTrue(it.hasNext());
final MethodSignature bindingHashCode = it.next();
- assertEquals(BindingMapping.BINDING_HASHCODE_NAME, bindingHashCode.getName());
+ assertEquals(Naming.BINDING_HASHCODE_NAME, bindingHashCode.getName());
final MethodSignature bindingEquals = it.next();
- assertEquals(BindingMapping.BINDING_EQUALS_NAME, bindingEquals.getName());
+ assertEquals(Naming.BINDING_EQUALS_NAME, bindingEquals.getName());
final MethodSignature bindingToString = it.next();
- assertEquals(BindingMapping.BINDING_TO_STRING_NAME, bindingToString.getName());
+ assertEquals(Naming.BINDING_TO_STRING_NAME, bindingToString.getName());
final MethodSignature getBar = it.next();
final Type getBarType = getBar.getReturnType();
assertTrue(getBarType instanceof GeneratedTransferObject);
assertTrue(getBarTO.isUnionType());
assertEquals(bar, getBarTO);
final MethodSignature requireBar = it.next();
- assertThat(requireBar.getName(), startsWith(BindingMapping.REQUIRE_PREFIX));
+ assertThat(requireBar.getName(), startsWith(Naming.REQUIRE_PREFIX));
assertFalse(it.hasNext());
final GeneratedProperty bar1Prop = bar.getProperties().stream().filter(prop -> "bar$1".equals(prop.getName()))
import org.opendaylight.mdsal.binding.model.api.GeneratedType
import org.opendaylight.mdsal.binding.model.api.Type
import org.opendaylight.mdsal.binding.model.ri.BindingTypes
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping
+import org.opendaylight.yangtools.yang.binding.contract.Naming
abstract class AbstractBuilderTemplate extends BaseTemplate {
static val Comparator<GeneratedProperty> KEY_PROPS_COMPARATOR = [ p1, p2 | return p1.name.compareTo(p2.name) ]
@«OVERRIDE.importedName»
«ELSE»
/**
- * Return current value associated with the property corresponding to {@link «targetType.importedName»#«BindingMapping.IDENTIFIABLE_KEY_NAME»()}.
+ * Return current value associated with the property corresponding to {@link «targetType.importedName»#«Naming.IDENTIFIABLE_KEY_NAME»()}.
*
* @return current value
*/
«ENDIF»
- public «keyType.importedName» «BindingMapping.IDENTIFIABLE_KEY_NAME»() {
+ public «keyType.importedName» «Naming.IDENTIFIABLE_KEY_NAME»() {
return key;
}
import org.opendaylight.mdsal.binding.model.api.Type
import org.opendaylight.mdsal.binding.model.api.TypeMemberComment
import org.opendaylight.mdsal.binding.model.ri.TypeConstants
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping
import org.opendaylight.yangtools.yang.binding.BaseIdentity
+import org.opendaylight.yangtools.yang.binding.contract.Naming
abstract class BaseTemplate extends JavaFileTemplate {
static final char NEW_LINE = '\n'
}
final protected def getterMethodName(String propName) {
- return '''«BindingMapping.GETTER_PREFIX»«propName.toFirstUpper»'''
+ return '''«Naming.GETTER_PREFIX»«propName.toFirstUpper»'''
}
/**
»'''
def protected emitConstant(Constant c) '''
- «IF BindingMapping.QNAME_STATIC_FIELD_NAME.equals(c.name)»
+ «IF Naming.QNAME_STATIC_FIELD_NAME.equals(c.name)»
«val entry = c.value as Entry<JavaTypeName, String>»
/**
* YANG identifier of the statement represented by this class.
*/
- public static final «c.type.importedNonNull» «c.name» = «entry.key.importedName».«BindingMapping.MODULE_INFO_QNAMEOF_METHOD_NAME»("«entry.value»");
- «ELSEIF BindingMapping.NAME_STATIC_FIELD_NAME.equals(c.name)»
+ public static final «c.type.importedNonNull» «c.name» = «entry.key.importedName».«Naming.MODULE_INFO_QNAMEOF_METHOD_NAME»("«entry.value»");
+ «ELSEIF Naming.NAME_STATIC_FIELD_NAME.equals(c.name)»
«val entry = c.value as Entry<JavaTypeName, String>»
/**
* Yang Data template name of the statement represented by this class.
*/
- public static final «c.type.importedNonNull» «c.name» = «entry.key.importedName».«BindingMapping.MODULE_INFO_YANGDATANAMEOF_METHOD_NAME»("«entry.value»");
- «ELSEIF BindingMapping.VALUE_STATIC_FIELD_NAME.equals(c.name) && BaseIdentity.equals(c.value)»
+ public static final «c.type.importedNonNull» «c.name» = «entry.key.importedName».«Naming.MODULE_INFO_YANGDATANAMEOF_METHOD_NAME»("«entry.value»");
+ «ELSEIF Naming.VALUE_STATIC_FIELD_NAME.equals(c.name) && BaseIdentity.equals(c.value)»
«val typeName = c.type.importedName»
«val override = OVERRIDE.importedName»
/**
*/
public static final «c.type.importedNonNull» «c.name» = new «typeName»() {
@«override»
- public «CLASS.importedName»<«typeName»> «BindingMapping.BINDING_CONTRACT_IMPLEMENTED_INTERFACE_NAME»() {
+ public «CLASS.importedName»<«typeName»> «Naming.BINDING_CONTRACT_IMPLEMENTED_INTERFACE_NAME»() {
return «typeName».class;
}
@«override»
public boolean equals(final «objectType.importedName» obj) {
return obj == this || obj instanceof «typeName» other
- && «typeName».class.equals(other.«BindingMapping.BINDING_CONTRACT_IMPLEMENTED_INTERFACE_NAME»());
+ && «typeName».class.equals(other.«Naming.BINDING_CONTRACT_IMPLEMENTED_INTERFACE_NAME»());
}
@«override»
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.ri.generated.type.builder.CodegenGeneratedTOBuilder;
import org.opendaylight.mdsal.binding.model.ri.generated.type.builder.CodegenGeneratedTypeBuilder;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.yang.binding.Augmentable;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.YangData;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
/**
* Transformator of the data from the virtual form to JAVA programming language. The result source code represent java
@Override
public String getUnitName(final Type type) {
- return type.getName() + BindingMapping.BUILDER_SUFFIX;
+ return type.getName() + Naming.BUILDER_SUFFIX;
}
@VisibleForTesting
static BuilderTemplate templateForType(final GeneratedType type) {
final JavaTypeName origName = type.getIdentifier();
- final JavaTypeName builderName = origName.createSibling(origName.simpleName() + BindingMapping.BUILDER_SUFFIX);
+ final JavaTypeName builderName = origName.createSibling(origName.simpleName() + Naming.BUILDER_SUFFIX);
return new BuilderTemplate(new CodegenGeneratedTypeBuilder(builderName)
.addEnclosingTransferObject(new CodegenGeneratedTOBuilder(
private static Type getKey(final GeneratedType type) {
for (MethodSignature m : type.getMethodDefinitions()) {
- if (BindingMapping.IDENTIFIABLE_KEY_NAME.equals(m.getName())) {
+ if (Naming.IDENTIFIABLE_KEY_NAME.equals(m.getName())) {
return m.getReturnType();
}
}
import static extension org.opendaylight.mdsal.binding.java.api.generator.GeneratorUtil.isNonPresenceContainer;
import static org.opendaylight.mdsal.binding.model.ri.Types.STRING;
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.AUGMENTATION_FIELD
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.BINDING_EQUALS_NAME
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.BINDING_HASHCODE_NAME
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.BINDING_TO_STRING_NAME
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.BUILDER_SUFFIX
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.AUGMENTATION_FIELD
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.BINDING_EQUALS_NAME
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.BINDING_HASHCODE_NAME
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.BINDING_TO_STRING_NAME
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.BUILDER_SUFFIX
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.IDENTIFIABLE_KEY_NAME
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.NONNULL_PREFIX
import java.util.Collection
import java.util.List
import org.opendaylight.mdsal.binding.model.api.MethodSignature.ValueMechanics
import org.opendaylight.mdsal.binding.model.api.Type
import org.opendaylight.mdsal.binding.model.ri.Types
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping
import org.opendaylight.yangtools.yang.binding.AbstractAugmentable
class BuilderImplTemplate extends AbstractBuilderTemplate {
def private generateGetters() '''
«IF keyType !== null»
@«OVERRIDE.importedName»
- public «keyType.importedName» «BindingMapping.IDENTIFIABLE_KEY_NAME»() {
+ public «keyType.importedName» «IDENTIFIABLE_KEY_NAME»() {
return key;
}
'''
def private nonnullMethodName(GeneratedProperty field) {
- return '''«BindingMapping.NONNULL_PREFIX»«field.name.toFirstUpper»'''
+ return '''«NONNULL_PREFIX»«field.name.toFirstUpper»'''
}
package def findGetter(String getterName) {
'''
override protected generateCopyKeys(List<GeneratedProperty> keyProps) '''
- if (base.«BindingMapping.IDENTIFIABLE_KEY_NAME»() != null) {
- this.key = base.«BindingMapping.IDENTIFIABLE_KEY_NAME»();
+ if (base.«IDENTIFIABLE_KEY_NAME»() != null) {
+ this.key = base.«IDENTIFIABLE_KEY_NAME»();
} else {
this.key = new «keyType.importedName»(«FOR keyProp : keyProps SEPARATOR ", "»base.«keyProp.getterMethodName»()«ENDFOR»);
}
import static extension org.apache.commons.text.StringEscapeUtils.escapeJava
import static extension org.opendaylight.mdsal.binding.java.api.generator.GeneratorUtil.isNonPresenceContainer;
import static org.opendaylight.mdsal.binding.model.ri.BindingTypes.DATA_OBJECT
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.AUGMENTABLE_AUGMENTATION_NAME
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.AUGMENTATION_FIELD
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.BINDING_CONTRACT_IMPLEMENTED_INTERFACE_NAME
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.IDENTIFIABLE_KEY_NAME
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.AUGMENTABLE_AUGMENTATION_NAME
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.AUGMENTATION_FIELD
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.BINDING_CONTRACT_IMPLEMENTED_INTERFACE_NAME
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.IDENTIFIABLE_KEY_NAME
import com.google.common.collect.ImmutableList
import com.google.common.collect.ImmutableSet
import org.opendaylight.mdsal.binding.model.api.Type
import org.opendaylight.mdsal.binding.model.ri.TypeConstants
import org.opendaylight.mdsal.binding.model.ri.Types
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping
+import org.opendaylight.yangtools.yang.binding.contract.Naming
/**
* Template for generating JAVA builder classes.
«IF (implementedIfc instanceof GeneratedType && !(implementedIfc instanceof GeneratedTransferObject))»
«val ifc = implementedIfc as GeneratedType»
«FOR getter : ifc.nonDefaultMethods»
- «IF BindingMapping.isGetterMethodName(getter.name)»
+ «IF Naming.isGetterMethodName(getter.name)»
«val propertyName = getter.propertyNameFromGetter»
«printPropertySetter(getter, '''arg.«getter.name»()''', propertyName)»;
«ENDIF»
«IF (implementedIfc instanceof GeneratedType && !(implementedIfc instanceof GeneratedTransferObject))»
«val ifc = implementedIfc as GeneratedType»
«FOR getter : ifc.nonDefaultMethods»
- «IF BindingMapping.isGetterMethodName(getter.name) && getterByName(alreadySetProperties, getter.name).isEmpty»
+ «IF Naming.isGetterMethodName(getter.name) && getterByName(alreadySetProperties, getter.name).isEmpty»
«val propertyName = getter.propertyNameFromGetter»
«printPropertySetter(getter, '''arg.«getter.name»()''', propertyName)»;
«ENDIF»
«IF (implementedIfc instanceof GeneratedType && !(implementedIfc instanceof GeneratedTransferObject))»
«val ifc = implementedIfc as GeneratedType»
«FOR getter : ifc.nonDefaultMethods»
- «IF BindingMapping.isGetterMethodName(getter.name) && !hasOverrideAnnotation(getter)»
+ «IF Naming.isGetterMethodName(getter.name) && !hasOverrideAnnotation(getter)»
«printPropertySetter(getter, '''castArg.«getter.name»()''', getter.propertyNameFromGetter)»;
«ENDIF»
«ENDFOR»
'''
override protected generateCopyKeys(List<GeneratedProperty> keyProps) '''
- this.key = base.«BindingMapping.IDENTIFIABLE_KEY_NAME»();
+ this.key = base.«IDENTIFIABLE_KEY_NAME»();
«FOR field : keyProps»
this.«field.fieldName» = base.«field.getterMethodName»();
«ENDFOR»
import org.opendaylight.mdsal.binding.model.api.Type
import org.opendaylight.mdsal.binding.model.ri.TypeConstants
import org.opendaylight.mdsal.binding.model.ri.Types
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping
+import org.opendaylight.yangtools.yang.binding.contract.Naming
import org.opendaylight.yangtools.yang.common.Empty
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition
def private scalarTypeObjectValue(GeneratedProperty field) '''
@«OVERRIDE.importedName»
- public «field.returnType.importedName» «BindingMapping.SCALAR_TYPE_OBJECT_GET_VALUE_NAME»() {
+ public «field.returnType.importedName» «Naming.SCALAR_TYPE_OBJECT_GET_VALUE_NAME»() {
return «field.fieldName»«field.cloneCall»;
}
'''
public boolean[] values() {
return new boolean[] {
«FOR bit : typedef.bits SEPARATOR ','»
- «BindingMapping.getPropertyName(bit.name).getterMethodName»()
+ «Naming.getPropertyName(bit.name).getterMethodName»()
«ENDFOR»
};
}
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.Type;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.yang.binding.YangFeature;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.QName;
final class FeatureTemplate extends ClassTemplate {
@SuppressWarnings("checkstyle:ParameterName")
@Override
protected CharSequence emitConstant(final Constant c) {
- if (!BindingMapping.VALUE_STATIC_FIELD_NAME.equals(c.getName()) || !YangFeature.class.equals(c.getValue())) {
+ if (!Naming.VALUE_STATIC_FIELD_NAME.equals(c.getName()) || !YangFeature.class.equals(c.getValue())) {
return super.emitConstant(c);
}
return "/**\n"
+ " * {@link " + typeName + "} singleton instance.\n"
+ " */\n"
- + "public static final " + importedName(type) + ' ' + BindingMapping.VALUE_STATIC_FIELD_NAME + " = new "
+ + "public static final " + importedName(type) + ' ' + Naming.VALUE_STATIC_FIELD_NAME + " = new "
+ type.getName() + "();";
}
final var rootName = importedName(dataRoot);
return '@' + override + '\n'
- + "public " + clazz + '<' + typeName + "> " + BindingMapping.BINDING_CONTRACT_IMPLEMENTED_INTERFACE_NAME
- + "() {\n"
+ + "public " + clazz + '<' + typeName + "> " + Naming.BINDING_CONTRACT_IMPLEMENTED_INTERFACE_NAME + "() {\n"
+ " return " + typeName + ".class;\n"
+ "}\n"
+ '\n'
+ '@' + override + '\n'
+ "public " + importedName(QNAME) + " qname() {\n"
- + " return " + BindingMapping.QNAME_STATIC_FIELD_NAME + ";\n"
+ + " return " + Naming.QNAME_STATIC_FIELD_NAME + ";\n"
+ "}\n"
+ '\n'
+ '@' + override + '\n'
*/
package org.opendaylight.mdsal.binding.java.api.generator
-import static extension org.opendaylight.mdsal.binding.spec.naming.BindingMapping.getGetterMethodForNonnull
-import static extension org.opendaylight.mdsal.binding.spec.naming.BindingMapping.getGetterMethodForRequire
-import static extension org.opendaylight.mdsal.binding.spec.naming.BindingMapping.isGetterMethodName
-import static extension org.opendaylight.mdsal.binding.spec.naming.BindingMapping.isNonnullMethodName
-import static extension org.opendaylight.mdsal.binding.spec.naming.BindingMapping.isRequireMethodName
+import static extension org.opendaylight.yangtools.yang.binding.contract.Naming.getGetterMethodForNonnull
+import static extension org.opendaylight.yangtools.yang.binding.contract.Naming.getGetterMethodForRequire
+import static extension org.opendaylight.yangtools.yang.binding.contract.Naming.isGetterMethodName
+import static extension org.opendaylight.yangtools.yang.binding.contract.Naming.isNonnullMethodName
+import static extension org.opendaylight.yangtools.yang.binding.contract.Naming.isRequireMethodName
import static org.opendaylight.mdsal.binding.model.ri.Types.BOOLEAN
import static org.opendaylight.mdsal.binding.model.ri.Types.STRING
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.REQUIRE_PREFIX
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.AUGMENTATION_FIELD
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.BINDING_CONTRACT_IMPLEMENTED_INTERFACE_NAME
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.BINDING_EQUALS_NAME
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.BINDING_HASHCODE_NAME
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.BINDING_TO_STRING_NAME
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.REQUIRE_PREFIX
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.AUGMENTATION_FIELD
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.BINDING_CONTRACT_IMPLEMENTED_INTERFACE_NAME
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.BINDING_EQUALS_NAME
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.BINDING_HASHCODE_NAME
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.BINDING_TO_STRING_NAME
import com.google.common.annotations.VisibleForTesting;
import java.util.List
import org.opendaylight.mdsal.binding.model.api.CodeGenerator;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.Type;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.plugin.generator.api.FileGenerator;
import org.opendaylight.yangtools.plugin.generator.api.FileGeneratorException;
import org.opendaylight.yangtools.plugin.generator.api.GeneratedFile;
import org.opendaylight.yangtools.plugin.generator.api.GeneratedFileType;
import org.opendaylight.yangtools.plugin.generator.api.ModuleResourceResolver;
import org.opendaylight.yangtools.yang.binding.YangModelBindingProvider;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
private static final Logger LOG = LoggerFactory.getLogger(JavaFileGenerator.class);
private static final CharMatcher DOT_MATCHER = CharMatcher.is('.');
- private static final String MODULE_INFO = BindingMapping.MODULE_INFO_CLASS_NAME + ".java";
- private static final String MODEL_BINDING_PROVIDER = BindingMapping.MODEL_BINDING_PROVIDER_CLASS_NAME + ".java";
+ private static final String MODULE_INFO = Naming.MODULE_INFO_CLASS_NAME + ".java";
+ private static final String MODEL_BINDING_PROVIDER = Naming.MODEL_BINDING_PROVIDER_CLASS_NAME + ".java";
private static final GeneratedFilePath MODEL_BINDING_PROVIDER_SERVICE =
GeneratedFilePath.ofPath("META-INF/services/" + YangModelBindingProvider.class.getName());
private static final List<CodeGenerator> GENERATORS = List.of(
import org.opendaylight.mdsal.binding.model.api.YangSourceDefinition.Single;
import org.opendaylight.mdsal.binding.model.ri.BindingTypes;
import org.opendaylight.mdsal.binding.model.ri.Types;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.yang.binding.Augmentable;
import org.opendaylight.yangtools.yang.binding.CodeHelpers;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
.addIgnoredStatement(YangStmtMapping.REFERENCE)
.addIgnoredStatement(YangStmtMapping.ORGANIZATION)
.build();
- private static final int GETTER_PREFIX_LENGTH = BindingMapping.GETTER_PREFIX.length();
+ private static final int GETTER_PREFIX_LENGTH = Naming.GETTER_PREFIX.length();
private static final Type AUGMENTATION_RET_TYPE;
static {
final Method m;
try {
- m = Augmentable.class.getDeclaredMethod(BindingMapping.AUGMENTABLE_AUGMENTATION_NAME, Class.class);
+ m = Augmentable.class.getDeclaredMethod(Naming.AUGMENTABLE_AUGMENTATION_NAME, Class.class);
} catch (NoSuchMethodException e) {
throw new ExceptionInInitializerError(e);
}
methods.add(implMethod);
} else {
final String implMethodName = implMethod.getName();
- if (BindingMapping.isGetterMethodName(implMethodName)
+ if (Naming.isGetterMethodName(implMethodName)
&& getterByName(methods, implMethodName).isEmpty()) {
methods.add(implMethod);
final String implMethodName) {
for (MethodSignature method : methods) {
final String methodName = method.getName();
- if (BindingMapping.isGetterMethodName(methodName) && isSameProperty(method.getName(), implMethodName)) {
+ if (Naming.isGetterMethodName(methodName) && isSameProperty(method.getName(), implMethodName)) {
return Optional.of(method);
}
}
protected static String propertyNameFromGetter(final String getterName) {
final String prefix;
- if (BindingMapping.isGetterMethodName(getterName)) {
- prefix = BindingMapping.GETTER_PREFIX;
- } else if (BindingMapping.isNonnullMethodName(getterName)) {
- prefix = BindingMapping.NONNULL_PREFIX;
- } else if (BindingMapping.isRequireMethodName(getterName)) {
- prefix = BindingMapping.REQUIRE_PREFIX;
+ if (Naming.isGetterMethodName(getterName)) {
+ prefix = Naming.GETTER_PREFIX;
+ } else if (Naming.isNonnullMethodName(getterName)) {
+ prefix = Naming.NONNULL_PREFIX;
+ } else if (Naming.isRequireMethodName(getterName)) {
+ prefix = Naming.REQUIRE_PREFIX;
} else {
throw new IllegalArgumentException(getterName + " is not a getter");
}
// sb.append("</i>\n");
if (hasBuilderClass(schema)) {
- final String builderName = genType.getName() + BindingMapping.BUILDER_SUFFIX;
+ final String builderName = genType.getName() + Naming.BUILDER_SUFFIX;
sb.append("\n<p>To create instances of this class use {@link ").append(builderName)
.append("}.\n")
if (node instanceof ListSchemaNode) {
final var keyDef = ((ListSchemaNode) node).getKeyDefinition();
if (!keyDef.isEmpty()) {
- sb.append("@see ").append(genType.getName()).append(BindingMapping.KEY_SUFFIX);
+ sb.append("@see ").append(genType.getName()).append(Naming.KEY_SUFFIX);
}
sb.append('\n');
}
if (method.isDefault()) {
return null;
}
- if (!BindingMapping.isGetterMethodName(method.getName())) {
+ if (!Naming.isGetterMethodName(method.getName())) {
return null;
}
import static org.opendaylight.mdsal.binding.model.ri.BaseYangTypes.STRING_TYPE
import static org.opendaylight.mdsal.binding.model.ri.Types.STRING
import static org.opendaylight.mdsal.binding.model.ri.Types.getOuterClassName
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.BINDING_CONTRACT_IMPLEMENTED_INTERFACE_NAME
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.BUILDER_SUFFIX
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.BINDING_CONTRACT_IMPLEMENTED_INTERFACE_NAME
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.BUILDER_SUFFIX
import static extension org.opendaylight.mdsal.binding.model.ri.BindingTypes.isBitsType
import static extension org.opendaylight.mdsal.binding.model.ri.BindingTypes.isIdentityType
*/
package org.opendaylight.mdsal.binding.java.api.generator
-import static extension org.opendaylight.mdsal.binding.spec.naming.BindingMapping.getClassName
-import static extension org.opendaylight.mdsal.binding.spec.naming.BindingMapping.getRootPackageName
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.MODEL_BINDING_PROVIDER_CLASS_NAME
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.MODULE_INFO_CLASS_NAME
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.MODULE_INFO_QNAMEOF_METHOD_NAME
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.MODULE_INFO_YANGDATANAMEOF_METHOD_NAME
+import static extension org.opendaylight.yangtools.yang.binding.contract.Naming.getClassName
+import static extension org.opendaylight.yangtools.yang.binding.contract.Naming.getRootPackageName
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.MODEL_BINDING_PROVIDER_CLASS_NAME
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.MODULE_INFO_CLASS_NAME
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.MODULE_INFO_QNAMEOF_METHOD_NAME
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.MODULE_INFO_YANGDATANAMEOF_METHOD_NAME
import com.google.common.base.Preconditions
import com.google.common.collect.ImmutableSet
import org.junit.BeforeClass;
import org.opendaylight.mdsal.binding.generator.impl.DefaultBindingGenerator;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.plugin.generator.api.GeneratedFile;
import org.opendaylight.yangtools.plugin.generator.api.GeneratedFilePath;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
mod -> Optional.of("fake/" + mod.getName()));
final File file = new File(new File(sourcesOutputDir,
- BindingMapping.getRootPackageName(module.getQNameModule()).replace('.', File.separatorChar)),
- BindingMapping.MODULE_INFO_CLASS_NAME + ".java");
+ Naming.getRootPackageName(module.getQNameModule()).replace('.', File.separatorChar)),
+ Naming.MODULE_INFO_CLASS_NAME + ".java");
Files.createParentDirs(file);
Files.asCharSink(file, StandardCharsets.UTF_8).write(template.generate());
}
import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.ri.Types;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
public class SpecializingLeafrefTest extends BaseCompilationTest {
private static final ParameterizedType SET_STRING_TYPE = Types.setTypeFor(Types.STRING);
}
private static String getJavaBuilderFileName(final String name) {
- return getJavaFileName(name + BindingMapping.BUILDER_SUFFIX);
+ return getJavaFileName(name + Naming.BUILDER_SUFFIX);
}
private String getFileContent(final String fileName) throws IOException {
import java.net.URL;
import java.net.URLClassLoader;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
/**
* Union constructor with indentityref. Previously identityref was ignored so that there is no constructor for
Class<?> unionTypeClass = Class.forName(CompilationTestUtils.BASE_PKG
+ ".urn.opendaylight.yang.union.test.rev160509.UnionType", true, loader);
- Object identOneValue = identOneClass.getDeclaredField(BindingMapping.VALUE_STATIC_FIELD_NAME).get(null);
+ Object identOneValue = identOneClass.getDeclaredField(Naming.VALUE_STATIC_FIELD_NAME).get(null);
// test UnionType with IdentOne argument
Constructor<?> unionTypeIdentBaseConstructor = CompilationTestUtils.assertContainsConstructor(unionTypeClass,
import java.net.URL;
import java.net.URLClassLoader;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
public class UnionWithMultipleIdentityrefsTest extends BaseCompilationTest {
@Test
Class<?> unionTypeClass = Class.forName(CompilationTestUtils.BASE_PKG
+ ".urn.opendaylight.yang.union.test.rev220428.UnionType", true, loader);
- Object identOneValue = identOneClass.getDeclaredField(BindingMapping.VALUE_STATIC_FIELD_NAME).get(null);
- Object identTwoValue = identTwoClass.getDeclaredField(BindingMapping.VALUE_STATIC_FIELD_NAME).get(null);
+ Object identOneValue = identOneClass.getDeclaredField(Naming.VALUE_STATIC_FIELD_NAME).get(null);
+ Object identTwoValue = identTwoClass.getDeclaredField(Naming.VALUE_STATIC_FIELD_NAME).get(null);
Constructor<?> unionTypeIdentOneConstructor = CompilationTestUtils.assertContainsConstructor(unionTypeClass,
identOneClass);
import static org.opendaylight.mdsal.binding.model.ri.Types.parameterizedTypeFor;
import static org.opendaylight.mdsal.binding.model.ri.Types.typeForClass;
-import static org.opendaylight.mdsal.binding.spec.naming.BindingMapping.VALUE_STATIC_FIELD_NAME;
+import static org.opendaylight.yangtools.yang.binding.contract.Naming.VALUE_STATIC_FIELD_NAME;
import com.google.common.annotations.Beta;
import com.google.common.annotations.VisibleForTesting;
import org.opendaylight.mdsal.binding.model.api.YangSourceDefinition;
import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotationTypeBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.util.LazyCollections;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
@Override
public final void updateEnumPairsFromEnumTypeDef(final EnumTypeDefinition enumTypeDef) {
final List<EnumPair> enums = enumTypeDef.getValues();
- final Map<String, String> valueIds = BindingMapping.mapEnumAssignedNames(enums.stream().map(EnumPair::getName)
+ final Map<String, String> valueIds = Naming.mapEnumAssignedNames(enums.stream().map(EnumPair::getName)
.collect(Collectors.toList()));
for (EnumPair enumPair : enums) {
import java.util.Map;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.runtime.api.ModuleInfoSnapshot;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.repo.api.MissingSchemaSourceException;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
@Override
public <T> Class<T> loadClass(final String fullyQualifiedName) throws ClassNotFoundException {
- final String packageName = BindingMapping.getModelRootPackageName(fullyQualifiedName);
+ final String packageName = Naming.getModelRootPackageName(fullyQualifiedName);
final ClassLoader loader = classLoaders.get(packageName);
if (loader == null) {
throw new ClassNotFoundException("Package " + packageName + " not found");
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.runtime.api.ModuleInfoSnapshot;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.yangtools.yang.binding.BindingObject;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.parser.api.YangParser;
mappedInfos.put(source.getIdentifier(), info);
final Class<?> infoClass = info.getClass();
- classLoaders.put(BindingMapping.getModelRootPackageName(infoClass.getPackage().getName()),
+ classLoaders.put(Naming.getModelRootPackageName(infoClass.getPackage().getName()),
infoClass.getClassLoader());
try {
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.runtime.api.ModuleInfoSnapshot;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.concepts.AbstractObjectRegistration;
import org.opendaylight.yangtools.concepts.Mutable;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleEffectiveStatement;
final var info = reg.info;
moduleInfos.put(source, info);
final var infoClass = info.getClass();
- classLoaders.put(BindingMapping.getModelRootPackageName(infoClass.getPackage().getName()),
+ classLoaders.put(Naming.getModelRootPackageName(infoClass.getPackage().getName()),
infoClass.getClassLoader());
}
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
module org.opendaylight.mdsal.binding.spec.util {
- exports org.opendaylight.mdsal.binding.spec.naming;
exports org.opendaylight.mdsal.binding.spec.reflect;
exports org.opendaylight.mdsal.binding.spec.util;
import java.util.ServiceLoader;
import java.util.concurrent.TimeUnit;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.util.ClassLoaderUtils;
import org.opendaylight.yangtools.yang.binding.Action;
import org.opendaylight.yangtools.yang.binding.Augmentable;
import org.opendaylight.yangtools.yang.binding.RpcService;
import org.opendaylight.yangtools.yang.binding.YangModelBindingProvider;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.YangConstants;
* Returns root package name for supplied package.
*
* @param pkg Package for which find model root package.
- * @deprecated Use {@link BindingMapping#getModelRootPackageName(String)} instead.
+ * @deprecated Use {@link Naming#getModelRootPackageName(String)} instead.
*/
@Deprecated(since = "11.0.3", forRemoval = true)
public static String getModelRootPackageName(final Package pkg) {
*
* @param name Package for which find model root package.
* @return Package of model root.
- * @deprecated Use {@link BindingMapping#getModelRootPackageName(String)} instead.
+ * @deprecated Use {@link Naming#getModelRootPackageName(String)} instead.
*/
@Deprecated(since = "11.0.3", forRemoval = true)
public static String getModelRootPackageName(final String name) {
checkArgument(name != null, "Package name should not be null.");
- return BindingMapping.getModelRootPackageName(name);
+ return Naming.getModelRootPackageName(name);
}
public static QNameModule getQNameModule(final Class<?> clz) {
* @return Instance of {@link YangModuleInfo} associated with model, from which this class was derived.
*/
public static @NonNull YangModuleInfo getModuleInfo(final Class<?> cls) {
- final String packageName = BindingMapping.getModelRootPackageName(cls.getPackage().getName());
+ final String packageName = Naming.getModelRootPackageName(cls.getPackage().getName());
final String potentialClassName = getModuleInfoClassName(packageName);
final Class<?> moduleInfoClass;
try {
}
public static @NonNull String getModuleInfoClassName(final String packageName) {
- return packageName + "." + BindingMapping.MODULE_INFO_CLASS_NAME;
+ return packageName + "." + Naming.MODULE_INFO_CLASS_NAME;
}
/**
if (DataContainer.class.isAssignableFrom(cls) || Augmentation.class.isAssignableFrom(cls)) {
return true;
}
- return cls.getName().startsWith(BindingMapping.PACKAGE_PREFIX);
+ return cls.getName().startsWith(Naming.PACKAGE_PREFIX);
}
/**
/**
* Tries to resolve QName for supplied class. Looks up for static field with name from constant
- * {@link BindingMapping#QNAME_STATIC_FIELD_NAME} and returns value if present. If field is not present uses
+ * {@link Naming#QNAME_STATIC_FIELD_NAME} and returns value if present. If field is not present uses
* {@link #computeQName(Class)} to compute QName for missing types.
*/
private static Optional<QName> resolveQNameNoCache(final Class<?> key) {
try {
final Field field;
try {
- field = key.getField(BindingMapping.QNAME_STATIC_FIELD_NAME);
+ field = key.getField(Naming.QNAME_STATIC_FIELD_NAME);
} catch (NoSuchFieldException e) {
LOG.debug("{} does not have a {} field, falling back to computation", key,
- BindingMapping.QNAME_STATIC_FIELD_NAME, e);
+ Naming.QNAME_STATIC_FIELD_NAME, e);
return Optional.of(computeQName(key));
}
return module;
} else if (isRpcType(key)) {
final String className = key.getSimpleName();
- if (className.endsWith(BindingMapping.RPC_OUTPUT_SUFFIX)) {
+ if (className.endsWith(Naming.RPC_OUTPUT_SUFFIX)) {
return YangConstants.operationOutputQName(module.getModule()).intern();
}
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.yang.binding.Augmentable;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.Item;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.binding.contract.Naming;
@Deprecated(since = "11.0.3", forRemoval = true)
public final class DataObjectReadingUtil {
public abstract DataContainer read(DataContainer parent, Class<?> child);
private static Method resolveGetterMethod(final Class<? extends DataContainer> parent, final Class<?> child) {
- String methodName = BindingMapping.GETTER_PREFIX + child.getSimpleName();
+ String methodName = Naming.GETTER_PREFIX + child.getSimpleName();
try {
return parent.getMethod(methodName);
} catch (NoSuchMethodException e) {
module org.opendaylight.yangtools.yang.binding {
exports org.opendaylight.yangtools.yang.binding;
exports org.opendaylight.yangtools.yang.binding.annotations;
+ exports org.opendaylight.yangtools.yang.binding.contract;
exports org.opendaylight.yangtools.yang.binding.util;
requires transitive org.opendaylight.yangtools.yang.common;
// Annotations
requires static transitive org.eclipse.jdt.annotation;
requires static com.github.spotbugs.annotations;
+ requires static org.checkerframework.checker.qual;
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.mdsal.binding.spec.naming;
+package org.opendaylight.yangtools.yang.binding.contract;
import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Objects.requireNonNull;
import org.opendaylight.yangtools.yang.common.Revision;
@Beta
-public final class BindingMapping {
+public final class Naming {
public static final @NonNull String VERSION = "0.6";
private static final Interner<String> PACKAGE_INTERNER = Interners.newWeakInterner();
@Regex
private static final String ROOT_PACKAGE_PATTERN_STRING =
- "(org.opendaylight.yang.gen.v1.[a-z0-9_\\.]*\\.(?:rev[0-9][0-9][0-1][0-9][0-3][0-9]|norev))";
+ "(org.opendaylight.yang.gen.v1.[a-z0-9_\\.]*?\\.(?:rev[0-9][0-9][0-1][0-9][0-3][0-9]|norev))";
private static final Pattern ROOT_PACKAGE_PATTERN = Pattern.compile(ROOT_PACKAGE_PATTERN_STRING);
- private BindingMapping() {
+ private Naming() {
// Hidden on purpose
}
}
public static @NonNull String getRootPackageName(final QNameModule module) {
- final StringBuilder packageNameBuilder = new StringBuilder().append(BindingMapping.PACKAGE_PREFIX).append('.');
+ final StringBuilder packageNameBuilder = new StringBuilder().append(PACKAGE_PREFIX).append('.');
String namespace = module.getNamespace().toString();
namespace = COLON_SLASH_SLASH.matcher(namespace).replaceAll(QUOTED_DOT);
builder.append('.');
}
- if (Character.isDigit(p.charAt(0)) || BindingMapping.JAVA_RESERVED_WORDS.contains(p)) {
+ if (Character.isDigit(p.charAt(0)) || JAVA_RESERVED_WORDS.contains(p)) {
builder.append('_');
}
builder.append(p);
PACKAGE_PREFIX, packageName);
final var match = ROOT_PACKAGE_PATTERN.matcher(packageName);
checkArgument(match.find(), "Package name '%s' does not match required pattern '%s'", packageName,
- ROOT_PACKAGE_PATTERN_STRING);
+ ROOT_PACKAGE_PATTERN_STRING);
return match.group(0);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.mdsal.binding.spec.naming;
+package org.opendaylight.yangtools.yang.binding.contract;
import static org.junit.Assert.assertEquals;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
-public class BindingMappingTest {
+public class NamingTest {
+
@Test
public void testGetModelRootPackageName() {
assertEquals("org.opendaylight.yang.gen.v1.test.rev990939",
- BindingMapping.getModelRootPackageName("org.opendaylight.yang.gen.v1.test.rev990939"));
+ Naming.getModelRootPackageName("org.opendaylight.yang.gen.v1.test.rev990939"));
}
@Test
public void testGetMethodName() {
- assertEquals("testLocalName", BindingMapping.getMethodName(QName.create("testNS", "testLocalName")));
- assertEquals("testYangIdentifier", BindingMapping.getMethodName("TestYangIdentifier"));
+ assertEquals("testLocalName", Naming.getMethodName(QName.create("testNS", "testLocalName")));
+ assertEquals("testYangIdentifier", Naming.getMethodName("TestYangIdentifier"));
}
@Test
public void testGetClassName() {
- assertEquals("TestClass", BindingMapping.getClassName(QName.create("testNS", "testClass")));
- assertEquals("TestClass", BindingMapping.getClassName("testClass"));
- assertEquals("", BindingMapping.getClassName(""));
- assertEquals("SomeTestingClassName", BindingMapping.getClassName(" some-testing_class name "));
- assertEquals("_0SomeTestingClassName", BindingMapping.getClassName(" 0 some-testing_class name "));
+ assertEquals("TestClass", Naming.getClassName(QName.create("testNS", "testClass")));
+ assertEquals("TestClass", Naming.getClassName("testClass"));
+ assertEquals("", Naming.getClassName(""));
+ assertEquals("SomeTestingClassName", Naming.getClassName(" some-testing_class name "));
+ assertEquals("_0SomeTestingClassName", Naming.getClassName(" 0 some-testing_class name "));
}
@Test
public void testGetPropertyName() {
- assertEquals("test", BindingMapping.getPropertyName("Test"));
- assertEquals("test", BindingMapping.getPropertyName("test"));
- assertEquals("xmlClass", BindingMapping.getPropertyName("Class"));
- assertEquals("_5", BindingMapping.getPropertyName("5"));
- assertEquals("", BindingMapping.getPropertyName(""));
- assertEquals("someTestingParameterName", BindingMapping.getPropertyName(" some-testing_parameter name "));
- assertEquals("_0someTestingParameterName",
- BindingMapping.getPropertyName(" 0some-testing_parameter name "));
+ assertEquals("test", Naming.getPropertyName("Test"));
+ assertEquals("test", Naming.getPropertyName("test"));
+ assertEquals("xmlClass", Naming.getPropertyName("Class"));
+ assertEquals("_5", Naming.getPropertyName("5"));
+ assertEquals("", Naming.getPropertyName(""));
+ assertEquals("someTestingParameterName", Naming.getPropertyName(" some-testing_parameter name "));
+ assertEquals("_0someTestingParameterName", Naming.getPropertyName(" 0some-testing_parameter name "));
}
@Test
public void basicTest() {
assertEquals("org.opendaylight.yang.gen.v1.test.uri.rev171026",
- BindingMapping.getRootPackageName(QName.create("test:URI", "2017-10-26", "test")));
+ Naming.getRootPackageName(QName.create("test:URI", "2017-10-26", "test")));
assertEquals("org.opendaylight.yang.gen.v1.urn.m.o.d.u.l.e.n.a.m.e.t.e.s.t._case._1digit.rev130910",
- BindingMapping.getRootPackageName(QNameModule.create(
+ Naming.getRootPackageName(QNameModule.create(
XMLNamespace.of("urn:m*o+d,u;l=e.n/a-m@e.t$e#s't.case.1digit"), Revision.of("2013-09-10"))));
- assertEquals("_1testpublic", BindingMapping.normalizePackageName("1testpublic"));
- assertEquals("Test", BindingMapping.getGetterSuffix(QName.create("test", "test")));
- assertEquals("XmlClass", BindingMapping.getGetterSuffix(QName.create("test", "class")));
+ assertEquals("_1testpublic", Naming.normalizePackageName("1testpublic"));
+ assertEquals("Test", Naming.getGetterSuffix(QName.create("test", "test")));
+ assertEquals("XmlClass", Naming.getGetterSuffix(QName.create("test", "class")));
}
@Test
expected.put(yang.get(i), mapped.get(i));
}
- assertEquals(expected, BindingMapping.mapEnumAssignedNames(yang));
+ assertEquals(expected, Naming.mapEnumAssignedNames(yang));
}
@Test
public void yangDataMapping() {
// single ascii compliant non-conflicting word - remain as is
- assertEquals("single", BindingMapping.mapYangDataName("single"));
+ assertEquals("single", Naming.mapYangDataName("single"));
// ascii compliant - non-compliany chars only encoded
- assertEquals("$abc$20$cde", BindingMapping.mapYangDataName("abc cde"));
+ assertEquals("$abc$20$cde", Naming.mapYangDataName("abc cde"));
// latin1 compliant -> latin chars normalized, non-compliant chars are encoded
- assertEquals("$ľaľaho$20$papľuhu", BindingMapping.mapYangDataName("ľaľaho papľuhu"));
+ assertEquals("$ľaľaho$20$papľuhu", Naming.mapYangDataName("ľaľaho papľuhu"));
// latin1 non-compliant - all non-compliant characters encoded
- assertEquals("$привет$20$papľuhu", BindingMapping.mapYangDataName("привет papľuhu"));
+ assertEquals("$привет$20$papľuhu", Naming.mapYangDataName("привет papľuhu"));
}
-}
+}
\ No newline at end of file
Code Review / mdsal.git / commitdiff