import java.util.TreeMap;
import java.util.regex.Pattern;
import org.opendaylight.mdsal.binding.generator.spi.TypeProvider;
+import org.opendaylight.mdsal.binding.generator.util.BaseYangTypesProvider;
import org.opendaylight.mdsal.binding.model.api.AccessModifier;
import org.opendaylight.mdsal.binding.model.api.ConcreteType;
import org.opendaylight.mdsal.binding.model.api.Enumeration;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
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.model.util.BaseYangTypes;
import org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil;
+import org.opendaylight.mdsal.binding.model.util.BindingTypes;
import org.opendaylight.mdsal.binding.model.util.TypeConstants;
import org.opendaylight.mdsal.binding.model.util.Types;
import org.opendaylight.mdsal.binding.model.util.generated.type.builder.AbstractEnumerationBuilder;
public abstract class AbstractTypeProvider implements TypeProvider {
private static final Logger LOG = LoggerFactory.getLogger(AbstractTypeProvider.class);
private static final Pattern GROUPS_PATTERN = Pattern.compile("\\[(.*?)\\]");
+ private static final JavaTypeName DEPRECATED_ANNOTATION = JavaTypeName.create(Deprecated.class);
// Backwards compatibility: Union types used to be instantiated in YANG namespace, which is no longer
// the case, as unions are emitted to their correct schema path.
// and generated an enclosing ExtendedType to hold any range constraints. The new parser instantiates
// a base type which holds these constraints.
if (typeDefinition instanceof DecimalTypeDefinition) {
- final Type ret = BaseYangTypes.BASE_YANG_TYPES_PROVIDER.javaTypeForSchemaDefinitionType(typeDefinition,
+ final Type ret = BaseYangTypesProvider.INSTANCE.javaTypeForSchemaDefinitionType(typeDefinition,
parentNode, restrictions, lenientRelativeLeafrefs);
if (ret != null) {
return ret;
return returnType;
}
+ public SchemaNode getTargetForLeafref(final LeafrefTypeDefinition leafrefType, final SchemaNode parentNode) {
+ final PathExpression xpath = leafrefType.getPathStatement();
+ Preconditions.checkArgument(xpath != null, "The Path Statement for Leafref Type Definition cannot be NULL!");
+
+ final Module module = findParentModule(schemaContext, parentNode);
+ Preconditions.checkArgument(module != null, "Failed to find module for parent %s", parentNode);
+
+ return xpath.isAbsolute() ? findDataTreeSchemaNode(schemaContext, module.getQNameModule(), xpath)
+ : findDataSchemaNodeForRelativeXPath(schemaContext, module, parentNode, xpath);
+ }
+
private GeneratedTransferObject shadedTOWithRestrictions(final GeneratedTransferObject gto,
final Restrictions restrictions) {
final GeneratedTOBuilder gtob = newGeneratedTOBuilder(gto.getIdentifier());
DataSchemaNode dataChildByName;
for (QName next : parentNode.getPath().getPathFromRoot()) {
if (current == null) {
- dataChildByName = schemaContext.getDataChildByName(next);
+ dataChildByName = schemaContext.dataChildByName(next);
} else {
- dataChildByName = current.getDataChildByName(next);
+ dataChildByName = current.dataChildByName(next);
}
if (dataChildByName == null) {
return false;
returnType = genTOs.get(typedefName);
}
if (returnType == null) {
- returnType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER.javaTypeForSchemaDefinitionType(
- baseTypeDef, typeDefinition, r, lenient);
+ returnType = BaseYangTypesProvider.INSTANCE.javaTypeForSchemaDefinitionType(baseTypeDef,
+ typeDefinition, r, lenient);
}
}
}
returnType = Types.listTypeFor(referencedTypes.get(dataNode.getPath()));
}
if (returnType == null) {
- returnType = resolveTypeFromDataSchemaNode(dataNode);
+ returnType = resolveTypeFromDataSchemaNode(dataNode, inGrouping);
}
Preconditions.checkArgument(returnType != null, "Failed to find leafref target: %s in module %s (%s)",
strXPath, this.getParentModule(parentNode).getName(), parentNode.getQName().getModule(), this);
* @param dataNode contains information about YANG type
* @return JAVA <code>Type</code> representation of <code>dataNode</code>
*/
- private Type resolveTypeFromDataSchemaNode(final SchemaNode dataNode) {
+ private Type resolveTypeFromDataSchemaNode(final SchemaNode dataNode, final boolean inGrouping) {
Type returnType = null;
if (dataNode != null) {
if (dataNode instanceof LeafSchemaNode) {
final LeafSchemaNode leaf = (LeafSchemaNode) dataNode;
final TypeDefinition<?> type = CompatUtils.compatType(leaf);
- returnType = javaTypeForSchemaDefinitionType(type, leaf);
+ returnType = javaTypeForSchemaDefinitionType(type, leaf, inGrouping);
} else if (dataNode instanceof LeafListSchemaNode) {
final LeafListSchemaNode leafList = (LeafListSchemaNode) dataNode;
- returnType = javaTypeForSchemaDefinitionType(leafList.getType(), leafList);
+ returnType = javaTypeForSchemaDefinitionType(leafList.getType(), leafList, inGrouping);
}
}
return returnType;
final GeneratedTOBuilder genTOBuilder = typedefToTransferObject(basePackageName, typedef, moduleName);
genTOBuilder.setRestrictions(BindingGeneratorUtil.getRestrictions(typedef));
- final GeneratedPropertyBuilder genPropBuilder = genTOBuilder.addProperty("value");
+ final GeneratedPropertyBuilder genPropBuilder = genTOBuilder.addProperty(TypeConstants.VALUE_PROP);
genPropBuilder.setReturnType(javaType);
+
genTOBuilder.addEqualsIdentity(genPropBuilder);
genTOBuilder.addHashIdentity(genPropBuilder);
genTOBuilder.addToStringProperty(genPropBuilder);
- genTOBuilder.addImplementsType(TYPE_OBJECT);
+ genTOBuilder.addImplementsType(BindingTypes.scalarTypeObject(javaType));
if (typedef.getStatus() == Status.DEPRECATED) {
- genTOBuilder.addAnnotation("java.lang", "Deprecated");
+ genTOBuilder.addAnnotation(DEPRECATED_ANNOTATION);
}
if (javaType instanceof ConcreteType && "String".equals(javaType.getName()) && typedef.getBaseType() != null) {
addStringRegExAsConstant(genTOBuilder, resolveRegExpressionsFromTypedef(typedef));
final TypeDefinition<?> baseType = baseTypeDefForExtendedType(unionSubtype);
if (unionTypeName.equals(baseType.getQName().getLocalName())) {
- final Type javaType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER.javaTypeForSchemaDefinitionType(baseType,
- parentNode, BindingGeneratorUtil.getRestrictions(unionSubtype));
+ final Type javaType = BaseYangTypesProvider.INSTANCE.javaTypeForSchemaDefinitionType(baseType, parentNode,
+ BindingGeneratorUtil.getRestrictions(unionSubtype));
if (javaType != null) {
updateUnionTypeAsProperty(parentUnionGenTOBuilder, javaType, unionTypeName);
}
addStringRegExAsConstant(genTOBuilder, resolveRegExpressionsFromTypedef(typedef));
if (typedef.getStatus() == Status.DEPRECATED) {
- genTOBuilder.addAnnotation("java.lang", "Deprecated");
+ genTOBuilder.addAnnotation(DEPRECATED_ANNOTATION);
}
if (baseTypeDefForExtendedType(innerExtendedType) instanceof UnionTypeDefinition) {
throw new UnsupportedOperationException("Cannot get default construction for identityref type");
} else if (base instanceof InstanceIdentifierTypeDefinition) {
throw new UnsupportedOperationException("Cannot get default construction for instance-identifier type");
- } else if (BaseTypes.isInt8(base)) {
+ } else if (isInt8(base)) {
result = typeToValueOfDef(Byte.class, defaultValue);
- } else if (BaseTypes.isInt16(base)) {
+ } else if (isInt16(base)) {
result = typeToValueOfDef(Short.class, defaultValue);
- } else if (BaseTypes.isInt32(base)) {
+ } else if (isInt32(base)) {
result = typeToValueOfDef(Integer.class, defaultValue);
- } else if (BaseTypes.isInt64(base)) {
+ } else if (isInt64(base)) {
result = typeToValueOfDef(Long.class, defaultValue);
} else if (base instanceof LeafrefTypeDefinition) {
result = leafrefToDef(node, (LeafrefTypeDefinition) base, defaultValue);
} else if (base instanceof StringTypeDefinition) {
result = "\"" + defaultValue + "\"";
- } else if (BaseTypes.isUint8(base)) {
+ } else if (isUint8(base)) {
result = typeToValueOfDef(Uint8.class, defaultValue);
- } else if (BaseTypes.isUint16(base)) {
+ } else if (isUint16(base)) {
result = typeToValueOfDef(Uint16.class, defaultValue);
- } else if (BaseTypes.isUint32(base)) {
+ } else if (isUint32(base)) {
result = typeToValueOfDef(Uint32.class, defaultValue);
- } else if (BaseTypes.isUint64(base)) {
+ } else if (isUint64(base)) {
result = typeToValueOfDef(Uint64.class, defaultValue);
} else if (base instanceof UnionTypeDefinition) {
result = unionToDef(node);
return sb.toString();
}
+
+ /**
+ * Check if a particular type definition represents the built-in int8 type.
+ *
+ * @param type Type definition
+ * @return True if the definition is the built-in int8 type.
+ */
+ private static boolean isInt8(final TypeDefinition<?> type) {
+ return BaseTypes.int8Type().getPath().equals(type.getPath());
+ }
+
+ /**
+ * Check if a particular type definition represents the built-in int16 type.
+ *
+ * @param type Type definition
+ * @return True if the definition is the built-in int16 type.
+ */
+ private static boolean isInt16(final TypeDefinition<?> type) {
+ return BaseTypes.int16Type().getPath().equals(type.getPath());
+ }
+
+ /**
+ * Check if a particular type definition represents the built-in int32 type.
+ *
+ * @param type Type definition
+ * @return True if the definition is the built-in int32 type.
+ */
+ private static boolean isInt32(final TypeDefinition<?> type) {
+ return BaseTypes.int32Type().getPath().equals(type.getPath());
+ }
+
+ /**
+ * Check if a particular type definition represents the built-in int64 type.
+ *
+ * @param type Type definition
+ * @return True if the definition is the built-in int64 type.
+ */
+ private static boolean isInt64(final TypeDefinition<?> type) {
+ return BaseTypes.int64Type().getPath().equals(type.getPath());
+ }
+
+ /**
+ * Check if a particular type is the base type for uint8.
+ *
+ * @param type The type to check
+ * @return If the type corresponds to the base uint8 type.
+ * @throws NullPointerException if type is null
+ */
+ private static boolean isUint8(final TypeDefinition<?> type) {
+ return BaseTypes.uint8Type().getPath().equals(type.getPath());
+ }
+
+ /**
+ * Check if a particular type is the base type for uint16.
+ *
+ * @param type The type to check
+ * @return If the type corresponds to the base uint16 type.
+ * @throws NullPointerException if type is null
+ */
+ private static boolean isUint16(final TypeDefinition<?> type) {
+ return BaseTypes.uint16Type().getPath().equals(type.getPath());
+ }
+
+ /**
+ * Check if a particular type is the base type for uint32.
+ *
+ * @param type The type to check
+ * @return If the type corresponds to the base uint32 type.
+ * @throws NullPointerException if type is null
+ */
+ private static boolean isUint32(final TypeDefinition<?> type) {
+ return BaseTypes.uint32Type().getPath().equals(type.getPath());
+ }
+
+ /**
+ * Check if a particular type is the base type for uint64.
+ *
+ * @param type The type to check
+ * @return If the type corresponds to the base uint64 type.
+ * @throws NullPointerException if type is null
+ */
+ private static boolean isUint64(final TypeDefinition<?> type) {
+ return BaseTypes.uint64Type().getPath().equals(type.getPath());
+ }
+
private static String typeToDef(final Class<?> clazz, final String defaultValue) {
return "new " + clazz.getName() + "(\"" + defaultValue + "\")";
}
bits.sort(BIT_NAME_COMPARATOR);
final StringBuilder sb = new StringBuilder();
if (!isExt) {
- sb.append("new ");
- sb.append(className);
- sb.append('(');
+ sb.append("new ").append(className).append('(');
}
for (int i = 0; i < bits.size(); i++) {
- if (bits.get(i).getName().equals(defaultValue)) {
- sb.append(true);
- } else {
- sb.append(false);
- }
+ sb.append(bits.get(i).getName().equals(defaultValue));
if (i != bits.size() - 1) {
sb.append(", ");
}
}
private static String union(final String className, final String defaultValue, final LeafSchemaNode node) {
- final StringBuilder sb = new StringBuilder();
- sb.append("new ");
- sb.append(className);
- sb.append("(\"");
- sb.append(defaultValue);
- sb.append("\".toCharArray())");
- return sb.toString();
+ return new StringBuilder()
+ .append("new ").append(className).append("(\"").append(defaultValue).append("\".toCharArray())")
+ .toString();
}
@Override
public String getConstructorPropertyName(final SchemaNode node) {
- return node instanceof TypeDefinition<?> ? "value" : "";
+ return node instanceof TypeDefinition<?> ? TypeConstants.VALUE_PROP : "";
}
@Override