interfaceBuilder.
*
* The method signature builder is created for the getter method of
* schemaNodeName. Also comment and
* returnType information are added to the builder.
*
* @param interfaceBuilder
* generated type builder for which the getter method should be
* created
* @param schemaNodeName
* string with schema node name. The name will be the part of the
* getter method name.
* @param comment
* string with comment for the getter method
* @param returnType
* type which represents the return type of the getter method
* @param status
* status from yang file, for deprecated annotation
* @return method signature builder which represents the getter method of
* interfaceBuilder
*/
static MethodSignatureBuilder constructGetter(final GeneratedTypeBuilder interfaceBuilder,
final String schemaNodeName, final String comment, final Type returnType, final Status status) {
final MethodSignatureBuilder getMethod = interfaceBuilder
.addMethod(getterMethodName(schemaNodeName, returnType));
if (status == Status.DEPRECATED) {
getMethod.addAnnotation("", "Deprecated");
}
getMethod.setComment(encodeAngleBrackets(comment));
getMethod.setReturnType(returnType);
return getMethod;
}
/**
* Creates the name of the getter method name from localName.
*
* @param localName
* string with the name of the getter method
* @param returnType
* return type
* @return string with the name of the getter method for
* methodName in JAVA method format
*/
private static String getterMethodName(final String localName, final Type returnType) {
final StringBuilder method = new StringBuilder();
if (BOOLEAN.equals(returnType)) {
method.append("is");
} else {
method.append("get");
}
// underscore used as separator for distinction of method parts in convertIdentifier()
method.append('_').append(localName);
return JavaIdentifierNormalizer.normalizeSpecificIdentifier(method.toString(), JavaIdentifier.METHOD);
}
static String createDescription(final SchemaNode schemaNode, final String fullyQualifiedName,
final SchemaContext schemaContext, final boolean verboseClassComments) {
final StringBuilder sb = new StringBuilder();
final String nodeDescription = encodeAngleBrackets(schemaNode.getDescription());
final String formattedDescription = YangTextTemplate.formatToParagraph(nodeDescription, 0);
if (!Strings.isNullOrEmpty(formattedDescription)) {
sb.append(formattedDescription);
sb.append(NEW_LINE);
}
if (verboseClassComments) {
final Module module = SchemaContextUtil.findParentModule(schemaContext, schemaNode);
final StringBuilder linkToBuilderClass = new StringBuilder();
final String[] namespace = Iterables.toArray(BSDOT_SPLITTER.split(fullyQualifiedName), String.class);
final String className = namespace[namespace.length - 1];
if (hasBuilderClass(schemaNode)) {
linkToBuilderClass.append(className);
linkToBuilderClass.append("Builder");
}
sb.append(""); sb.append("This class represents the following YANG schema fragment defined in module "); sb.append(module.getName()); sb.append(""); sb.append(NEW_LINE); sb.append("
");
sb.append(NEW_LINE);
String formedYang = YangSnippetCleaner.clean(yangTemplateForNode.render(schemaNode, module).body());
sb.append(encodeAngleBrackets(formedYang));
sb.append("");
sb.append(NEW_LINE);
sb.append("The schema path to identify an instance is");
sb.append(NEW_LINE);
sb.append("");
sb.append(YangTextTemplate.formatSchemaPath(module.getName(), schemaNode.getPath().getPathFromRoot()));
sb.append("");
sb.append(NEW_LINE);
if (hasBuilderClass(schemaNode)) {
sb.append(NEW_LINE);
sb.append("To create instances of this class use " + "{@link " + linkToBuilderClass + "}.");
sb.append(NEW_LINE);
sb.append("@see ");
sb.append(linkToBuilderClass);
sb.append(NEW_LINE);
if (schemaNode instanceof ListSchemaNode) {
final List ");
sb.append("This class represents the following YANG schema fragment defined in module ");
sb.append(module.getName());
sb.append("");
sb.append(NEW_LINE);
sb.append("");
sb.append(NEW_LINE);
String formedYang = YangSnippetCleaner.clean(yangTemplateForModule.render(module).body());
sb.append(encodeAngleBrackets(formedYang));
sb.append("");
}
return replaceAllIllegalChars(sb);
}
static String createDescription(final Set schemaNodes, final Module module, final
boolean verboseClassComments) {
final StringBuilder sb = new StringBuilder();
if (!isNullOrEmpty(schemaNodes)) {
final SchemaNode node = schemaNodes.iterator().next();
if (node instanceof RpcDefinition) {
sb.append("Interface for implementing the following YANG RPCs defined in module " + module.getName() + "");
} else if (node instanceof NotificationDefinition) {
sb.append("Interface for receiving the following YANG notifications defined in module " + module.getName() + "");
}
}
sb.append(NEW_LINE);
if (verboseClassComments) {
sb.append("");
sb.append(NEW_LINE);
sb.append(encodeAngleBrackets(yangTemplateForNodes.render(schemaNodes, module).body()));
sb.append("");
sb.append(NEW_LINE);
}
return replaceAllIllegalChars(sb);
}
private static boolean isNullOrEmpty(final Collection list) {
return list == null || list.isEmpty();
}
/**
* Returns first unique name for the augment generated type builder. The
* generated type builder name for augment consists from name of augmented
* node and serial number of its augmentation.
*
* @param builders
* map of builders which were created in the package to which the
* augmentation belongs
* @param genTypeName
* string with name of augmented node
* @return string with unique name for augmentation builder
*/
static String augGenTypeName(final MapenumTypeDef to
* typeBuilder.
*
* Each enumTypeDef item is added to builder with its name and
* value.
*
* @param enumTypeDef
* EnumTypeDefinition contains enum data
* @param enumName
* string contains name which will be assigned to enumeration
* builder
* @param typeBuilder
* GeneratedTypeBuilder to which will be enum builder assigned
* @param module
* Module in which type should be generated
* @return enumeration builder which contains data from
* enumTypeDef
*/
static EnumBuilder resolveInnerEnumFromTypeDefinition(final EnumTypeDefinition enumTypeDef, final QName enumName,
final MaptypeDef of type
* {@link UnionTypeDefinition} or {@link BitsTypeDefinition} which are
* also added to typeBuilder as enclosing transfer object.
*
* If more then one generated TO builder is created for enclosing then all
* of the generated TO builders are added to typeBuilder as
* enclosing transfer objects.
*
* @param typeDef
* type definition which can be of type UnionType or
* BitsTypeDefinition
* @param typeBuilder
* generated type builder to which is added generated TO created
* from typeDef
* @param leaf
* string with name for generated TO builder
* @param parentModule
* parent module
* @return generated TO builder for typeDef
*/
static GeneratedTOBuilder addTOToTypeBuilder(final TypeDefinition typeDef, final GeneratedTypeBuilder
typeBuilder, final DataSchemaNode leaf, final Module parentModule, final TypeProvider typeProvider,
final SchemaContext schemaContext) {
final String classNameFromLeaf = leaf.getQName().getLocalName();
final Listlist which contains any list keys special
* generated TO builder.
*
* @param packageName
* string with package name to which the list belongs
* @param list
* schema node of list
* @return generated TO builder which represents the keys of the
* list or empty TO builder if list is null or list of
* key definitions is null or empty.
*/
static GeneratedTOBuilder resolveListKeyTOBuilder(final String packageName, final ListSchemaNode list) {
GeneratedTOBuilder genTOBuilder = null;
if ((list.getKeyDefinition() != null) && (!list.getKeyDefinition().isEmpty())) {
// underscore used as separator for distinction of class name parts
final String genTOName =
new StringBuilder(list.getQName().getLocalName()).append('_').append(BindingNamespaceType.Key)
.toString();
genTOBuilder =
new GeneratedTOBuilderImpl(new StringBuilder(packageName).append(".wrapper").toString(), genTOName);
}
return genTOBuilder;
}
/**
* Converts leaf schema node to property of generated TO
* builder.
*
* @param toBuilder
* generated TO builder to which is leaf added as
* property
* @param leaf
* leaf schema node which is added to toBuilder as
* property
* @param returnType
* property type
* @param isReadOnly
* boolean value which says if leaf property is|isn't read only
* @return boolean value
*
*
*/
static boolean resolveLeafSchemaNodeAsProperty(final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf,
final Type returnType, final boolean isReadOnly) {
if (returnType == null) {
return false;
}
final String leafName = leaf.getQName().getLocalName();
final String leafDesc = encodeAngleBrackets(leaf.getDescription());
final GeneratedPropertyBuilder propBuilder =
toBuilder.addProperty(JavaIdentifierNormalizer.normalizeSpecificIdentifier(leafName, JavaIdentifier.METHOD));
propBuilder.setReadOnly(isReadOnly);
propBuilder.setReturnType(returnType);
propBuilder.setComment(leafDesc);
toBuilder.addEqualsIdentity(propBuilder);
toBuilder.addHashIdentity(propBuilder);
toBuilder.addToStringProperty(propBuilder);
return true;
}
static void checkModuleAndModuleName(final Module module) {
checkArgument(module != null, "Module reference cannot be NULL.");
checkArgument(module.getName() != null, "Module name cannot be NULL.");
}
@VisibleForTesting
public static String replaceAllIllegalChars(final StringBuilder stringBuilder){
final String ret = UNICODE_CHAR_PATTERN.matcher(stringBuilder).replaceAll("\\\\\\\\u");
return ret.isEmpty() ? "" : ret;
}
}
leaf, toBuilder or leaf
* name equals null or if leaf is added by uses.