'''
}
- def String wrapToDocumentation(String text) {
+ def static String wrapToDocumentation(String text) {
if (text.empty)
return ""
return sb.toString();
}
- def protected String formatDataForJavaDoc(TypeMember type, String additionalComment) {
+ def protected static String formatDataForJavaDoc(TypeMember type, String additionalComment) {
val StringBuilder typeDescriptionBuilder = new StringBuilder();
if (!type.comment.nullOrEmpty) {
typeDescriptionBuilder.append(formatToParagraph(type.comment))
return sb.toString
}
- protected def formatToParagraph(String text) {
+ protected static def formatToParagraph(String text) {
if(text === null || text.isEmpty)
return text
«ENDIF»
«ENDFOR»
'''
-
- def protected Restrictions restrictionsForSetter(Type actualType) {
- if (actualType instanceof GeneratedType) {
- return null;
- }
- return actualType.restrictions;
- }
-
- def protected generateInnerClass(GeneratedType innerClass) '''
- «IF innerClass instanceof GeneratedTransferObject»
- «val innerJavaType = javaType.getEnclosedType(innerClass.identifier)»
- «IF innerClass.unionType»
- «new UnionTemplate(innerJavaType, innerClass).generateAsInnerClass»
- «ELSE»
- «new ClassTemplate(innerJavaType, innerClass).generateAsInnerClass»
- «ENDIF»
- «ENDIF»
- '''
-
- def static Restrictions getRestrictions(Type type) {
- if (type instanceof ConcreteType) {
- return type.restrictions
- }
- if (type instanceof GeneratedTransferObject) {
- return type.restrictions
- }
- return null
- }
}
import java.util.Optional;
import java.util.stream.Collectors;
+import org.opendaylight.mdsal.binding.model.api.ConcreteType;
import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+import org.opendaylight.mdsal.binding.model.api.Restrictions;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.util.Types;
final Optional<JavaTypeName> optEnc = name.immediatelyEnclosingClass();
return optEnc.isPresent() && type.getIdentifier().equals(optEnc.get());
}
+
+ final CharSequence generateInnerClass(final GeneratedType innerClass) {
+ if (!(innerClass instanceof GeneratedTransferObject)) {
+ return "";
+ }
+
+ final GeneratedTransferObject gto = (GeneratedTransferObject) innerClass;
+ final NestedJavaGeneratedType innerJavaType = javaType.getEnclosedType(innerClass.getIdentifier());
+ return gto.isUnionType() ? new UnionTemplate(innerJavaType, gto).generateAsInnerClass()
+ : new ClassTemplate(innerJavaType, gto).generateAsInnerClass();
+ }
+
+ static final Restrictions restrictionsForSetter(final Type actualType) {
+ return actualType instanceof GeneratedType ? null : getRestrictions(actualType);
+ }
+
+ static final Restrictions getRestrictions(final Type type) {
+ if (type instanceof ConcreteType) {
+ return ((ConcreteType) type).getRestrictions();
+ }
+ if (type instanceof GeneratedTransferObject) {
+ return ((GeneratedTransferObject) type).getRestrictions();
+ }
+ return null;
+ }
}