static int basicHashCode(final @NonNull TypeDefinition<?> type) { return Objects.hash(type.getPath(), type.getUnknownSchemaNodes(), type.getBaseType(), type.getUnits().orElse(null), type.getDefaultValue().orElse(null)); }
/** * Returns true if supplied type is representation of built-in YANG type as * per RFC 6020. * * <p> * See package documentation for description of base types. * * @param type Type definition * @return true if type is built-in YANG Types. */ public static boolean isYangBuildInType(final TypeDefinition<?> type) { return type != null && BUILT_IN_TYPES.contains(type.getQName()); } }
static @NonNull ToStringHelper toStringHelper(final @NonNull TypeDefinition<?> type) { return MoreObjects.toStringHelper(type).omitNullValues() .add("path", type.getPath()) .add("baseType", type.getBaseType()) .add("default", type.getDefaultValue().orElse(null)) .add("description", type.getDescription().orElse(null)) .add("reference", type.getReference().orElse(null)) .add("status", type.getStatus()) .add("units", type.getUnits().orElse(null)); }
DerivedTypeBuilder(final T baseType, final SchemaPath path) { super(requireNonNull(baseType), path); checkArgument(baseType instanceof AbstractBaseType || baseType instanceof AbstractDerivedType || baseType instanceof AbstractRestrictedType, "Derived type can be built only from a base, derived, or restricted type, not %s", baseType); // http://tools.ietf.org/html/rfc6020#section-7.3.4 defaultValue = baseType.getDefaultValue().orElse(null); // In similar vein, it makes sense to propagate units units = baseType.getUnits().orElse(null); }
ConcreteTypeBuilder(final T baseType, final SchemaPath path) { super(baseType, path); setStatus(baseType.getStatus()); baseType.getDescription().ifPresent(this::setDescription); baseType.getReference().ifPresent(this::setReference); }
/** * Converts <code>typedef</code> to the generated TO builder. * * @param basePackageName * string with name of package to which the module belongs * @param typedef * type definition from which is the generated TO builder created * @return generated TO builder which contains data from * <code>typedef</code> and <code>basePackageName</code> */ private static GeneratedTOBuilderImpl typedefToTransferObject(final String basePackageName, final TypeDefinition<?> typedef, final String moduleName) { final String packageName = packageNameForGeneratedType(basePackageName, typedef.getPath()); final String typeDefTOName = typedef.getQName().getLocalName(); if ((packageName != null) && (typeDefTOName != null)) { final String genTOName = BindingMapping.getClassName(typeDefTOName); final GeneratedTOBuilderImpl newType = new GeneratedTOBuilderImpl(packageName, genTOName); newType.setDescription(typedef.getDescription()); newType.setReference(typedef.getReference()); newType.setSchemaPath(typedef.getPath().getPathFromRoot()); newType.setModuleName(moduleName); return newType; } return null; }
private static TypeDefinition<?> getBaseOrDeclaredType(final TypeDefinition<?> typeDef) { // Returns DerivedType in case of new parser. final TypeDefinition<?> baseType = typeDef.getBaseType(); return baseType != null && baseType.getBaseType() != null ? baseType : typeDef; }
private static Module findParentModuleOfReferencingType(final SchemaContext schemaContext, final SchemaNode schemaNode) { checkArgument(schemaContext != null, "Schema Context reference cannot be NULL!"); checkArgument(schemaNode instanceof TypedDataSchemaNode, "Unsupported node %s", schemaNode); TypeDefinition<?> nodeType = ((TypedDataSchemaNode) schemaNode).getType(); if (nodeType.getBaseType() != null) { while (nodeType.getBaseType() != null) { nodeType = nodeType.getBaseType(); } return schemaContext.findModule(nodeType.getQName().getModule()).orElse(null); } return SchemaContextUtil.findParentModule(schemaContext, schemaNode); }
private boolean resolveLeafSchemaNodeAsProperty(final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf, final boolean isReadOnly) { if (leaf != null && toBuilder != null) { Type returnType; final TypeDefinition<?> typeDef = CompatUtils.compatLeafType(leaf); if (typeDef instanceof UnionTypeDefinition) { // GeneratedType for this type definition should have be already created final ModuleContext mc = moduleContext(typeDef.getQName().getModule()); returnType = mc.getTypedefs().get(typeDef.getPath()); if (returnType == null) { // This may still be an inner type, try to find it returnType = mc.getInnerType(typeDef.getPath()); } } else if (typeDef instanceof EnumTypeDefinition && typeDef.getBaseType() == null) { // Annonymous enumeration (already generated, since it is inherited via uses). LeafSchemaNode originalLeaf = (LeafSchemaNode) SchemaNodeUtils.getRootOriginalIfPossible(leaf); QName qname = originalLeaf.getQName(); returnType = moduleContext(qname.getModule()).getInnerType(originalLeaf.getType().getPath()); } else { returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf); } return resolveLeafSchemaNodeAsProperty(toBuilder, leaf, returnType, isReadOnly); } return false; }
public void addTypedefType(final TypeDefinition<?> def, final Type type) { final JavaTypeName name = type.getIdentifier(); final SchemaNode existingDef = nameMapping.putIfAbsent(name, def); if (existingDef != null) { if (!(existingDef instanceof TypeDefinition)) { throw resolveNamingConfict(existingDef, def, name); } // This seems to be fine LOG.debug("GeneratedType conflict between {} and {} on {}", def, existingDef, name); } typedefs.put(def.getPath(), type); }
private void emitTypedefNode(final TypeDefinition<?> typedef) { super.writer.startTypedefNode(typedef.getQName()); // Differentiate between derived type and existing type // name. emitTypeNodeDerived(typedef); typedef.getUnits().ifPresent(this::emitUnitsNode); typedef.getDefaultValue().ifPresent(this::emitDefaultNode); emitDocumentedNode(typedef); emitUnknownStatementNodes(typedef.getUnknownSchemaNodes()); super.writer.endNode(); }
String className; if (type.getBaseType() != null) { final QName typeQName = type.getQName(); Module module = null; final Set<Module> modules = schemaContext.findModules(typeQName.getNamespace()); return union(className, (String) node.getType().getDefaultValue().orElse(null), node);
final TypeDefinition<?> baseTypedef = typedef.getBaseType(); final String typedefName = typedef.getQName().getLocalName(); if (baseTypedef.getBaseType() != null) { returnType = provideGeneratedTOFromExtendedType(typedef, baseTypedef, basePackageName, module.getName()); } else if (baseTypedef instanceof UnionTypeDefinition) { final GeneratedTOBuilder genTOBuilder = provideGeneratedTOBuilderForUnionTypeDef( JavaTypeName.create(basePackageName, BindingMapping.getClassName(typedef.getQName())), (UnionTypeDefinition) baseTypedef, typedef); genTOBuilder.setTypedef(true); genTOBuilder.setIsUnion(true); addUnitsToGenTO(genTOBuilder, typedef.getUnits().orElse(null)); makeSerializable(genTOBuilder); returnType = genTOBuilder.build(); } else if (baseTypedef instanceof BitsTypeDefinition) { final GeneratedTOBuilder genTOBuilder = provideGeneratedTOBuilderForBitsTypeDefinition( JavaTypeName.create(basePackageName, BindingMapping.getClassName(typedef.getQName())), (BitsTypeDefinition) baseTypedef, module.getName()); genTOBuilder.setTypedef(true); addUnitsToGenTO(genTOBuilder, typedef.getUnits().orElse(null)); makeSerializable(genTOBuilder); returnType = genTOBuilder.build();
BindingMapping.getClassName(typedef.getQName()))); genTOBuilder.setSchemaPath(typedef.getPath()); genTOBuilder.setModuleName(moduleName); genTOBuilder.setTypedef(true); addStringRegExAsConstant(genTOBuilder, resolveRegExpressionsFromTypedef(typedef)); if (typedef.getStatus() == Status.DEPRECATED) { genTOBuilder.addAnnotation("java.lang", "Deprecated"); final String innerTypeDef = innerExtendedType.getQName().getLocalName(); final Type type = typeMap.get(innerTypeDef); if (type instanceof GeneratedTransferObject) { addUnitsToGenTO(genTOBuilder, typedef.getUnits().orElse(null)); makeSerializable(genTOBuilder);
public static String getGetterMethodName(final TypedDataSchemaNode node) { // Bug 8903: If it is a derived type of boolean or empty, not an inner type, then the return type // of method would be the generated type of typedef not build-in types, so here it should be 'get'. final TypeDefinition<?> type = node.getType(); return BindingMapping.getGetterMethodName(node.getQName(), (type instanceof BooleanTypeDefinition || type instanceof EmptyTypeDefinition) && (type.getPath().equals(node.getPath()) || type.getBaseType() == null)); } }
private static Object createDefaultObject(final DataSchemaNode schema, final Codec<Object, Object> codec, final SchemaContext schemaContext) { if (schema instanceof LeafSchemaNode) { TypeDefinition<?> type = ((LeafSchemaNode) schema).getType(); Optional<? extends Object> defaultValue = type.getDefaultValue(); if (defaultValue.isPresent()) { if (type instanceof IdentityrefTypeDefinition) { return qnameDomValueFromString(codec, schema, (String) defaultValue.get(), schemaContext); } return domValueFromString(codec, type, defaultValue.get()); } while (type.getBaseType() != null && !type.getDefaultValue().isPresent()) { type = type.getBaseType(); } defaultValue = type.getDefaultValue(); if (defaultValue.isPresent()) { if (type instanceof IdentityrefTypeDefinition) { return qnameDomValueFromString(codec, schema, (String) defaultValue.get(), schemaContext); } return domValueFromString(codec, type, defaultValue.get()); } } return null; }
/** * Wraps base YANG type to generated TO. * * @param basePackageName string with name of package to which the module belongs * @param typedef type definition which is converted to the TO * @param javaType JAVA <code>Type</code> to which is <code>typedef</code> mapped * @return generated transfer object which represent<code>javaType</code> */ private GeneratedTransferObject wrapJavaTypeIntoTO(final String basePackageName, final TypeDefinition<?> typedef, final Type javaType, final String moduleName) { Preconditions.checkNotNull(javaType, "javaType cannot be null"); final GeneratedTOBuilder genTOBuilder = typedefToTransferObject(basePackageName, typedef, moduleName); genTOBuilder.setRestrictions(BindingGeneratorUtil.getRestrictions(typedef)); final GeneratedPropertyBuilder genPropBuilder = genTOBuilder.addProperty("value"); genPropBuilder.setReturnType(javaType); genTOBuilder.addEqualsIdentity(genPropBuilder); genTOBuilder.addHashIdentity(genPropBuilder); genTOBuilder.addToStringProperty(genPropBuilder); if (typedef.getStatus() == Status.DEPRECATED) { genTOBuilder.addAnnotation("java.lang", "Deprecated"); } if (javaType instanceof ConcreteType && "String".equals(javaType.getName()) && typedef.getBaseType() != null) { addStringRegExAsConstant(genTOBuilder, resolveRegExpressionsFromTypedef(typedef)); } addUnitsToGenTO(genTOBuilder, typedef.getUnits().orElse(null)); genTOBuilder.setTypedef(true); makeSerializable(genTOBuilder); return genTOBuilder.build(); }
/** * Converts <code>typedef</code> to the generated TO builder. * * @param basePackageName string with name of package to which the module belongs * @param typedef type definition from which is the generated TO builder created * @return generated TO builder which contains data from <code>typedef</code> and <code>basePackageName</code> */ private GeneratedTOBuilder typedefToTransferObject(final String basePackageName, final TypeDefinition<?> typedef, final String moduleName) { JavaTypeName name = renames.get(typedef); if (name == null) { name = JavaTypeName.create( BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, typedef.getPath()), BindingMapping.getClassName(typedef.getQName().getLocalName())); } final GeneratedTOBuilder newType = newGeneratedTOBuilder(name); newType.setSchemaPath(typedef.getPath()); newType.setModuleName(moduleName); addCodegenInformation(newType, typedef); return newType; }
final GeneratedTOBuilderImpl genTOBuilder = new GeneratedTOBuilderImpl(basePackageName, typeName); genTOBuilder.setDescription(typeDef.getDescription()); genTOBuilder.setReference(typeDef.getReference()); genTOBuilder.setSchemaPath(typeDef.getPath().getPathFromRoot()); genTOBuilder.setModuleName(moduleName); genTOBuilder.setBaseType(typeDef);
@Override public final Optional<String> getUnits() { return baseType.getUnits(); }