import org.opendaylight.mdsal.binding.javav2.generator.impl.util.YangTextTemplate;
import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifier;
-import org.opendaylight.mdsal.binding.javav2.generator.util.NonJavaCharsConverter;
+import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifierNormalizer;
import org.opendaylight.mdsal.binding.javav2.generator.util.Types;
import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
import org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeProviderImpl;
}
// underscore used as separator for distinction of method parts in convertIdentifier()
method.append('_').append(localName);
- return NonJavaCharsConverter.convertIdentifier(method.toString(), JavaIdentifier.METHOD);
+ return JavaIdentifierNormalizer.normalizeSpecificIdentifier(method.toString(), JavaIdentifier.METHOD);
}
static String createDescription(final SchemaNode schemaNode, final String fullyQualifiedName,
final String leafName = leaf.getQName().getLocalName();
final String leafDesc = encodeAngleBrackets(leaf.getDescription());
final GeneratedPropertyBuilder propBuilder =
- toBuilder.addProperty(NonJavaCharsConverter.convertIdentifier(leafName, JavaIdentifier.METHOD));
+ toBuilder.addProperty(JavaIdentifierNormalizer.normalizeSpecificIdentifier(leafName, JavaIdentifier.METHOD));
propBuilder.setReadOnly(isReadOnly);
propBuilder.setReturnType(returnType);
propBuilder.setComment(leafDesc);
import org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil;
import org.opendaylight.mdsal.binding.javav2.generator.util.BindingTypes;
import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifier;
-import org.opendaylight.mdsal.binding.javav2.generator.util.NonJavaCharsConverter;
+import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifierNormalizer;
import org.opendaylight.mdsal.binding.javav2.generator.util.Types;
import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedPropertyBuilderImpl;
import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
}
sb.append(notificationInterface.getName());
- listenerInterface.addMethod(NonJavaCharsConverter.convertIdentifier(sb.toString(), JavaIdentifier.METHOD))
+ listenerInterface.addMethod(JavaIdentifierNormalizer.normalizeSpecificIdentifier(sb.toString(), JavaIdentifier.METHOD))
.setAccessModifier(AccessModifier.PUBLIC).addParameter(notificationInterface, "notification")
.setComment(encodeAngleBrackets(notification.getDescription())).setReturnType(Types.VOID);
return listenerInterface;
import java.util.Map;
import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifier;
-import org.opendaylight.mdsal.binding.javav2.generator.util.NonJavaCharsConverter;
+import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifierNormalizer;
import org.opendaylight.mdsal.binding.javav2.generator.util.Types;
import org.opendaylight.mdsal.binding.javav2.model.api.Restrictions;
import org.opendaylight.mdsal.binding.javav2.model.api.Type;
@Override
public String getParamNameFromType(final TypeDefinition<?> type) {
- return NonJavaCharsConverter.convertIdentifier(type.getQName().getLocalName(), JavaIdentifier.METHOD);
+ return JavaIdentifierNormalizer.normalizeSpecificIdentifier(type.getQName().getLocalName(),
+ JavaIdentifier.METHOD);
}
};
import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
import org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil;
import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifier;
-import org.opendaylight.mdsal.binding.javav2.generator.util.NonJavaCharsConverter;
+import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifierNormalizer;
import org.opendaylight.mdsal.binding.javav2.generator.util.Types;
import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedPropertyBuilderImpl;
import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
for (final Bit bit : bitList) {
final String name = bit.getName();
genPropertyBuilder =
- genTOBuilder.addProperty(NonJavaCharsConverter.convertIdentifier(name, JavaIdentifier.METHOD));
+ genTOBuilder.addProperty(JavaIdentifierNormalizer.normalizeSpecificIdentifier(name, JavaIdentifier.METHOD));
genPropertyBuilder.setReadOnly(true);
genPropertyBuilder.setReturnType(BaseYangTypes.BOOLEAN_TYPE);
final String basePackageName = BindingMapping.getRootPackageName(module);
final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, typeDefinition
.getPath(), BindingNamespaceType.Typedef);
- final String genTOName = NonJavaCharsConverter.normalizeClassIdentifier(packageName, typedefName);
+ final String genTOName = JavaIdentifierNormalizer.normalizeClassIdentifier(packageName, typedefName);
final String name = packageName + "." + genTOName;
if (!(returnType.getFullyQualifiedName().equals(name))) {
returnType = shadedTOWithRestrictions(gto, r);
final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, identity.getPath
(), BindingNamespaceType.Typedef);
final String genTypeName =
- NonJavaCharsConverter.normalizeClassIdentifier(packageName, identity.getQName().getLocalName());
+ JavaIdentifierNormalizer.normalizeClassIdentifier(packageName, identity.getQName().getLocalName());
final Type baseType = Types.typeForClass(Class.class);
final Type paramType = Types.wildcardTypeFor(packageName, genTypeName);
private static void updateUnionTypeAsProperty(final GeneratedTOBuilder unionGenTransObject, final Type type, final String propertyName) {
if (unionGenTransObject != null && type != null && !unionGenTransObject.containsProperty(propertyName)) {
final GeneratedPropertyBuilder propBuilder = unionGenTransObject
- .addProperty(NonJavaCharsConverter.convertIdentifier(propertyName, JavaIdentifier.METHOD));
+ .addProperty(JavaIdentifierNormalizer.normalizeSpecificIdentifier(propertyName, JavaIdentifier.METHOD));
propBuilder.setReturnType(type);
unionGenTransObject.addEqualsIdentity(propBuilder);
final GeneratedPropertyBuilder propertyBuilder;
propertyBuilder = parentUnionGenTOBuilder
- .addProperty(NonJavaCharsConverter.convertIdentifier(newTOBuilderName, JavaIdentifier.METHOD));
+ .addProperty(JavaIdentifierNormalizer.normalizeSpecificIdentifier(newTOBuilderName, JavaIdentifier.METHOD));
propertyBuilder.setReturnType(subUnionGenTOBUilders.get(0));
parentUnionGenTOBuilder.addEqualsIdentity(propertyBuilder);
parentUnionGenTOBuilder.addToStringProperty(propertyBuilder);
protected AbstractBaseType(final String pkName, final String name) {
Preconditions.checkNotNull(pkName, "Package Name for Generated Type cannot be null!");
Preconditions.checkNotNull(name, "Name of Generated Type cannot be null!");
- this.packageName = NonJavaCharsConverter.convertFullPackageName(pkName);
- this.name = NonJavaCharsConverter.normalizeClassIdentifier(pkName, name);
+ this.packageName = JavaIdentifierNormalizer.normalizeFullPackageName(pkName);
+ this.name = JavaIdentifierNormalizer.normalizeClassIdentifier(pkName, name);
}
/**
this.packageName = pkName;
this.name = name;
} else {
- this.packageName = NonJavaCharsConverter.convertFullPackageName(pkName);
- this.name = NonJavaCharsConverter.normalizeClassIdentifier(pkName, name);
+ this.packageName = JavaIdentifierNormalizer.normalizeFullPackageName(pkName);
+ this.name = JavaIdentifierNormalizer.normalizeClassIdentifier(pkName, name);
}
}
sb.append(basePackageName)
.append('.')
.append(namespaceType.getPackagePrefix());
- return NonJavaCharsConverter.convertFullPackageName(sb.toString());
+ return JavaIdentifierNormalizer.normalizeFullPackageName(sb.toString());
}
- return NonJavaCharsConverter.convertFullPackageName(basePackageName);
+ return JavaIdentifierNormalizer.normalizeFullPackageName(basePackageName);
}
return generateNormalizedPackageName(basePackageName, pathFromRoot, size, namespaceType);
final String nodeLocalName = iterator.next().getLocalName();
builder.append(nodeLocalName);
}
- final String normalizedPackageName = NonJavaCharsConverter.convertFullPackageName(builder.toString());
+ final String normalizedPackageName = JavaIdentifierNormalizer.normalizeFullPackageName(builder.toString());
// Prevent duplication of input
PACKAGE_INTERNER.intern(normalizedPackageName);
return normalizedPackageName;
import com.google.common.annotations.Beta;
import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ListMultimap;
import java.util.List;
+import java.util.Set;
import org.opendaylight.mdsal.binding.javav2.model.api.Enumeration;
import org.opendaylight.mdsal.binding.javav2.model.api.Enumeration.Pair;
import org.opendaylight.mdsal.binding.javav2.util.BindingMapping;
/**
- * This util class converts every non-java char in identifier to java char by its unicode name
- * (<a href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.8">JAVA SE
- * SPEFICIATIONS - Identifiers</a>). There are special types of mapping non-java chars to original
- * identifiers according to specific {@linkplain JavaIdentifier java type}:
+ * This util class converts every non-java char in identifier to java char by
+ * its unicode name (<a href=
+ * "http://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.8">JAVA SE
+ * SPECIFICATIONS - Identifiers</a>). There are special types of mapping
+ * non-java chars to original identifiers according to specific
+ * {@linkplain JavaIdentifier java type}:
* <ul>
* <li>class, enum, interface</li>
* <li>
* <ul>
* <li>without special separator</li>
- * <li>the first character of identifier, any other first character of identifier part mapped by
- * non-Java char name from unicode and char in identifier behind non-java char name are converting
- * to upper case</li>
+ * <li>the first character of identifier, any other first character of
+ * identifier part mapped by non-Java char name from unicode and char in
+ * identifier behind non-java char name are converting to upper case</li>
* <li>examples:</li>
* <li>
* <ul>
* <ul>
* <li>without special separator</li>
* <li>the first character of identifier is converting to lower case</li>
- * <li>any other first character of identifier part mapped by non-Java char name from unicode and
- * char in identifier behind non-java char name are converting to upper case</li>
+ * <li>any other first character of identifier part mapped by non-Java char name
+ * from unicode and char in identifier behind non-java char name are converting
+ * to upper case</li>
* <li>examples:</li>
* <li>
* <ul>
* </li>
* </ul>
* </li>
- * <li>package - full package name
- * (<a href="https://docs.oracle.com/javase/tutorial/java/package/namingpkgs.html"> Naming a
- * package</a>)</li>
+ * <li>package - full package name (<a href=
+ * "https://docs.oracle.com/javase/tutorial/java/package/namingpkgs.html">
+ * Naming a package</a>)</li>
* <li>
* <li>
* <ul>
* <li>parts of package name are separated by dots</li>
* <li>parts of package name are converting to lower case</li>
- * <li>if parts of package name are reserved Java or Windows keywords, such as 'int' the suggested
- * convention is to add an underscore to keyword</li>
- * <li>dash is parsed as underscore according to
- * <a href="https://docs.oracle.com/javase/tutorial/java/package/namingpkgs.html"> Naming a
- * package</a></li>
+ * <li>if parts of package name are reserved Java or Windows keywords, such as
+ * 'int' the suggested convention is to add an underscore to keyword</li>
+ * <li>dash is parsed as underscore according to <a href=
+ * "https://docs.oracle.com/javase/tutorial/java/package/namingpkgs.html">
+ * Naming a package</a></li>
* <li>examples:</li>
* <li>
* <ul>
* </li>
* </ul>
*
- * There is special case in CLASS, INTERFACE, ENUM, ENUM VALUE, CONSTANT, METHOD and VARIABLE if
- * identifier contains single dash - then the converter ignores the single dash in the way of the
- * non-java chars. In other way, if dash is the first or the last char in the identifier or there is
- * more dashes in a row in the identifier, then these dashes are converted as non-java chars.
+ * There is special case in CLASS, INTERFACE, ENUM, ENUM VALUE, CONSTANT, METHOD
+ * and VARIABLE if identifier contains single dash - then the converter ignores
+ * the single dash in the way of the non-java chars. In other way, if dash is
+ * the first or the last char in the identifier or there is more dashes in a row
+ * in the identifier, then these dashes are converted as non-java chars.
* Example:
* <ul>
* <li>class, enum, interface</li>
* </li>
* </ul>
*
- * Next special case talks about normalizing class name which already exists in package - but with
- * different camel cases (foo, Foo, fOo, ...). To every next classes with same names will by added
- * their actual rank (serial number), except the first one. This working for CLASS, ENUM and
- * INTEFACE java identifiers. If there exist the same ENUM VALUES in ENUM (with different camel
- * cases), then it's parsed with same logic like CLASSES, ENUMS and INTERFACES but according to list
- * of pairs of their ENUM parent. Example:
+ * Next special case talks about normalizing class name which already exists in
+ * package - but with different camel cases (foo, Foo, fOo, ...). To every next
+ * classes with same names will by added their actual rank (serial number),
+ * except the first one. This working for CLASS, ENUM and INTEFACE java
+ * identifiers. If there exist the same ENUM VALUES in ENUM (with different
+ * camel cases), then it's parsed with same logic like CLASSES, ENUMS and
+ * INTERFACES but according to list of pairs of their ENUM parent. Example:
*
* <ul>
* <li>class, enum, interface</li>
* <li>
* <ul>
- * <li>package name org.example, class (or interface or enum) Foo - normalized to Foo
- * <li>package name org.example, class (or interface or enum) fOo - normalized to Foo1
+ * <li>package name org.example, class (or interface or enum) Foo - normalized
+ * to Foo
+ * <li>package name org.example, class (or interface or enum) fOo - normalized
+ * to Foo1
* </ul>
* </li>
* <li>enum value</li>
* </pre>
*
* </li>
- * <li>YANG enum values will be mapped to 'FOO' and 'FOO_1' Java enum values.</li>
+ * <li>YANG enum values will be mapped to 'FOO' and 'FOO_1' Java enum
+ * values.</li>
* </ul>
* </li>
* </ul>
*/
@Beta
-public final class NonJavaCharsConverter {
+public final class JavaIdentifierNormalizer {
private static final int FIRST_CHAR = 0;
private static final int FIRST_INDEX = 1;
private static final String EMPTY_STRING = "";
private static final String RESERVED_KEYWORD = "reserved_keyword";
private static final ListMultimap<String, String> PACKAGES_MAP = ArrayListMultimap.create();
+ public static final Set<String> SPECIAL_RESERVED_WORDS = ImmutableSet.of("QName");
- private NonJavaCharsConverter() {
+ private JavaIdentifierNormalizer() {
throw new UnsupportedOperationException("Util class");
}
* - list of all actual enum values
* @return converted and fixed name of new enum value
*/
- public static String
convertIdentifierEnumValue(final String name, final List<Pair> values) {
+ public static String
normalizeEnumValueIdentifier(final String name, final List<Pair> values) {
return convertIdentifierEnumValue(name, name, values, FIRST_INDEX);
}
* - full package name
* @return normalized name
*/
- public static String convertFullPackageName(final String fullPackageName) {
+ public static String normalizeFullPackageName(final String fullPackageName) {
final String[] packageNameParts = fullPackageName.split("\\.");
final StringBuilder sb = new StringBuilder();
for (int i = 0; i < packageNameParts.length; i++) {
- sb.append(NonJavaCharsConverter.normalizePackageNamePart(packageNameParts[i]));
+ sb.append(normalizePartialPackageName(packageNameParts[i]));
if (i != (packageNameParts.length - 1)) {
sb.append(".");
}
* - part of package name
* @return normalized name
*/
- public static String normalizePackageNamePart(final String packageNamePart) {
+ public static String normalizePartialPackageName(final String packageNamePart) {
// if part of package name consist from java or windows reserved word, return it with
// underscore at the end and in lower case
if (BindingMapping.JAVA_RESERVED_WORDS.contains(packageNamePart.toLowerCase())
for (int i = 0; i < normalizedPackageNamePart.length(); i++) {
if (normalizedPackageNamePart.charAt(i) == UNDERSCORE) {
if (!innserSb.toString().isEmpty()) {
- sb.append(convertIdentifier(innserSb.toString(), JavaIdentifier.PACKAGE));
+ sb.append(normalizeSpecificIdentifier(innserSb.toString(), JavaIdentifier.PACKAGE));
innserSb = new StringBuilder();
}
sb.append(UNDERSCORE);
}
}
if (!innserSb.toString().isEmpty()) {
- sb.append(convertIdentifier(innserSb.toString(), JavaIdentifier.PACKAGE));
+ sb.append(normalizeSpecificIdentifier(innserSb.toString(), JavaIdentifier.PACKAGE));
}
// returned normalized part of package name
return sb.toString();
* @return - java acceptable identifier
*/
public static String normalizeClassIdentifier(final String packageName, final String className) {
- final String convertedClassName = convertIdentifier(className, JavaIdentifier.CLASS);
+ final String convertedClassName = normalizeSpecificIdentifier(className, JavaIdentifier.CLASS);
return normalizeClassIdentifier(packageName, convertedClassName, convertedClassName, FIRST_INDEX);
}
- /**
- * Checking while there doesn't exist any class name with the same name (regardless of camel
- * cases) in package.
- *
- * @param packageName
- * - package of class name
- * @param origClassName
- * - original class name
- * @param actualClassName
- * - actual class name with rank (serial number)
- * @param rank
- * - actual rank (serial number)
- * @return converted identifier
- */
- private static String normalizeClassIdentifier(final String packageName, final String origClassName,
- final String actualClassName, final int rank) {
- if (PACKAGES_MAP.containsKey(packageName)) {
- for (final String existingName : PACKAGES_MAP.get(packageName)) {
- if (existingName.toLowerCase().equals(actualClassName.toLowerCase())) {
- final int nextRank = rank + 1;
- return normalizeClassIdentifier(packageName, origClassName,
- new StringBuilder(origClassName).append(rank).toString(), nextRank);
- }
- }
- }
- PACKAGES_MAP.put(packageName, actualClassName);
- return actualClassName;
- }
-
/**
* Find and convert non Java chars in identifiers of generated transfer objects, initially
* derived from corresponding YANG.
* - java type of identifier
* @return - java acceptable identifier
*/
- public static String convertIdentifier(final String identifier, final JavaIdentifier javaIdentifier) {
+ public static String normalizeSpecificIdentifier(final String identifier, final JavaIdentifier javaIdentifier) {
+ if (SPECIAL_RESERVED_WORDS.contains(identifier)) {
+ return identifier;
+ }
+
final StringBuilder sb = new StringBuilder();
// if identifier isn't PACKAGE type then check it by reserved keywords
return fixCasesByJavaType(sb.toString().replace("__", "_").toLowerCase(), javaIdentifier);
}
+ /**
+ * Checking while there doesn't exist any class name with the same name
+ * (regardless of camel cases) in package.
+ *
+ * @param packageName
+ * - package of class name
+ * @param origClassName
+ * - original class name
+ * @param actualClassName
+ * - actual class name with rank (serial number)
+ * @param rank
+ * - actual rank (serial number)
+ * @return converted identifier
+ */
+ private static String normalizeClassIdentifier(final String packageName, final String origClassName,
+ final String actualClassName, final int rank) {
+ if (PACKAGES_MAP.containsKey(packageName)) {
+ for (final String existingName : PACKAGES_MAP.get(packageName)) {
+ if (existingName.toLowerCase().equals(actualClassName.toLowerCase())) {
+ final int nextRank = rank + 1;
+ return normalizeClassIdentifier(packageName, origClassName,
+ new StringBuilder(origClassName).append(rank).toString(), nextRank);
+ }
+ }
+ }
+ PACKAGES_MAP.put(packageName, actualClassName);
+ return actualClassName;
+ }
+
/**
* Fix cases of converted identifiers by Java type
*
newName = convertIdentifierEnumValue(actualNameBuilder.toString(), origName, values, ++actualRank);
}
}
- return convertIdentifier(newName, JavaIdentifier.ENUM_VALUE);
+ return normalizeSpecificIdentifier(newName, JavaIdentifier.ENUM_VALUE);
}
}
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.mdsal.binding.javav2.generator.util.AbstractBaseType;
-import org.opendaylight.mdsal.binding.javav2.generator.util.NonJavaCharsConverter;
+import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifierNormalizer;
import org.opendaylight.mdsal.binding.javav2.model.api.AnnotationType;
import org.opendaylight.mdsal.binding.javav2.model.api.Constant;
import org.opendaylight.mdsal.binding.javav2.model.api.Enumeration;
final String reference, final Status status, final List<Pair> values) {
this.name = name;
- this.mappedName = NonJavaCharsConverter.convertIdentifierEnumValue(name, values);
+ this.mappedName = JavaIdentifierNormalizer.normalizeEnumValueIdentifier(name, values);
this.value = value;
this.description = description;
this.reference = reference;
import org.junit.Test;
import org.opendaylight.mdsal.binding.javav2.util.BindingMapping;
-public class NonJavaCharsConverterTest {
+public class JavaIdentifierNormalizerTest {
+
+ @Test
+ public void specialWordsTest(){
+ String normalizeIdentifier = JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.same.package", "QName");
+ assertEquals("QName", normalizeIdentifier);
+ }
/**
* This test tests normalizing of enum and interface identifiers too.
*/
@Test
public void sameClassNamesSamePackageTest() {
- String normalizeIdentifier1 = NonJavaCharsConverter.normalizeClassIdentifier("org.example.same.package", "Foo");
- String normalizeIdentifier2 = NonJavaCharsConverter.normalizeClassIdentifier("org.example.same.package", "fOo");
+ String normalizeIdentifier1 = JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.same.package", "Foo");
+ String normalizeIdentifier2 = JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.same.package", "fOo");
final String normalizeIdentifier3 =
- NonJavaCharsConverter.normalizeClassIdentifier("org.example.same.package", "foo");
+ JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.same.package", "foo");
assertEquals(normalizeIdentifier1, "Foo");
assertEquals(normalizeIdentifier2, "Foo1");
assertEquals(normalizeIdentifier3, "Foo2");
- normalizeIdentifier1 = NonJavaCharsConverter.normalizeClassIdentifier("org.example.same.package", "*");
- normalizeIdentifier2 = NonJavaCharsConverter.normalizeClassIdentifier("org.example.same.package", "asterisk");
+ normalizeIdentifier1 = JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.same.package", "*");
+ normalizeIdentifier2 = JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.same.package", "asterisk");
assertEquals(normalizeIdentifier1, "Asterisk");
assertEquals(normalizeIdentifier2, "Asterisk1");
}
@Test
public void sameClassNamesOtherPackageTest() {
String normalizeIdentifier1 =
- NonJavaCharsConverter.normalizeClassIdentifier("org.example.other.package", "Foo");
+ JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.other.package", "Foo");
String normalizeIdentifier2 =
- NonJavaCharsConverter.normalizeClassIdentifier("org.example.other.package.next", "fOo");
+ JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.other.package.next", "fOo");
final String normalizeIdentifier3 =
- NonJavaCharsConverter.normalizeClassIdentifier("org.example.other.package.next.next", "foo");
+ JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.other.package.next.next", "foo");
assertEquals(normalizeIdentifier1, "Foo");
assertEquals(normalizeIdentifier2, "Foo");
assertEquals(normalizeIdentifier3, "Foo");
- normalizeIdentifier1 = NonJavaCharsConverter.normalizeClassIdentifier("org.example.other.package", "*");
+ normalizeIdentifier1 = JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.other.package", "*");
normalizeIdentifier2 =
- NonJavaCharsConverter.normalizeClassIdentifier("org.example.other.package.next", "asterisk");
+ JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.other.package.next", "asterisk");
assertEquals(normalizeIdentifier1, "Asterisk");
assertEquals(normalizeIdentifier2, "Asterisk");
}
@Test
public void sameClassNamesSamePackageReservedWordsTest() {
final String normalizeIdentifier1 =
- NonJavaCharsConverter.normalizeClassIdentifier("org.example.keywords.same.package", "int");
+ JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.keywords.same.package", "int");
final String normalizeIdentifier2 =
- NonJavaCharsConverter.normalizeClassIdentifier("org.example.keywords.same.package", "InT");
+ JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.keywords.same.package", "InT");
final String normalizeIdentifier3 =
- NonJavaCharsConverter.normalizeClassIdentifier("org.example.keywords.same.package", "inT");
+ JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.keywords.same.package", "inT");
assertEquals(normalizeIdentifier1, "IntReservedKeyword");
assertEquals(normalizeIdentifier2, "IntReservedKeyword1");
assertEquals(normalizeIdentifier3, "IntReservedKeyword2");
@Test
public void sameClassNamesOtherPackageReservedWordsTest() {
final String normalizeIdentifier1 =
- NonJavaCharsConverter.normalizeClassIdentifier("org.example.keywords.other.package", "int");
+ JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.keywords.other.package", "int");
final String normalizeIdentifier2 =
- NonJavaCharsConverter.normalizeClassIdentifier("org.example.keywords.other.package.next", "InT");
+ JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.keywords.other.package.next", "InT");
final String normalizeIdentifier3 =
- NonJavaCharsConverter.normalizeClassIdentifier("org.example.keywords.other.package.next.next", "inT");
+ JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.keywords.other.package.next.next", "inT");
assertEquals(normalizeIdentifier1, "IntReservedKeyword");
assertEquals(normalizeIdentifier2, "IntReservedKeyword");
assertEquals(normalizeIdentifier3, "IntReservedKeyword");
}
private void testPackageReservedKeyword(final String reservedKeyword) {
- final String packageNameNormalizer = NonJavaCharsConverter.normalizePackageNamePart(reservedKeyword);
+ final String packageNameNormalizer = JavaIdentifierNormalizer.normalizePartialPackageName(reservedKeyword);
final StringBuilder expected = new StringBuilder(reservedKeyword).append('_');
assertEquals(expected.toString().toLowerCase(), packageNameNormalizer);
}
public void digitAtStartTest() {
for (int i = 0; i < 10; i++) {
final String str_i = String.valueOf(i);
- final String packageNameNormalizer = NonJavaCharsConverter.normalizePackageNamePart(str_i);
+ final String packageNameNormalizer = JavaIdentifierNormalizer.normalizePartialPackageName(str_i);
final String expected = Character.getName(str_i.charAt(0)).replaceAll(" ", "").toLowerCase();
assertEquals(expected.toString(), packageNameNormalizer);
}
}
private void dashTest(final String tested, final String expected) {
- final String actual = NonJavaCharsConverter.normalizePackageNamePart(tested);
+ final String actual = JavaIdentifierNormalizer.normalizePartialPackageName(tested);
assertEquals(expected, actual);
}
}
private void normalizePackageNameTest(final String tested, final Object expected) {
- final String packageNameNormalizer = NonJavaCharsConverter.normalizePackageNamePart(tested);
+ final String packageNameNormalizer = JavaIdentifierNormalizer.normalizePartialPackageName(tested);
assertEquals(expected, packageNameNormalizer);
}
private void assertTest(final String testedIdentifier, final String acceptable,
final JavaIdentifier javaTypeOfIdentifier) {
final String convertedIdentifier =
- NonJavaCharsConverter.convertIdentifier(testedIdentifier, javaTypeOfIdentifier);
+ JavaIdentifierNormalizer.normalizeSpecificIdentifier(testedIdentifier, javaTypeOfIdentifier);
assertNotNull(convertedIdentifier);
assertTrue(!convertedIdentifier.isEmpty());
assertEquals(acceptable, convertedIdentifier);
}
private void testRealPackageNameExample(final String tested, final String expected) {
- final String actual = NonJavaCharsConverter.convertFullPackageName(tested);
+ final String actual = JavaIdentifierNormalizer.normalizeFullPackageName(tested);
assertEquals(expected, actual);
}
}
*@
@import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifier.CLASS
-@import org.opendaylight.mdsal.binding.javav2.generator.util.NonJavaCharsConverter.convertIdentifier
+@import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifierNormalizer.normalizeSpecificIdentifier
@import org.opendaylight.mdsal.binding.javav2.java.api.generator.util.TextTemplateUtil.getFormattedRevision
@import org.opendaylight.mdsal.binding.javav2.java.api.generator.util.TextTemplateUtil.getSourcePath
@import org.opendaylight.mdsal.binding.javav2.java.api.generator.renderers.YangModuleInfoTemplateRenderer.getSortedQName
@generateSubInfo(module: Module) = {
@for(submodule <- module.getSubmodules) {
- private static final class @{convertIdentifier(submodule.getName, CLASS)}Info implements @{importedNames.get("yangModuleInfo")} {
+ private static final class @{normalizeSpecificIdentifier(submodule.getName, CLASS)}Info implements @{importedNames.get("yangModuleInfo")} {
- private static final @{importedNames.get("yangModuleInfo")} INSTANCE = new @{convertIdentifier(submodule.getName, CLASS)}Info();
+ private static final @{importedNames.get("yangModuleInfo")} INSTANCE = new @{normalizeSpecificIdentifier(submodule.getName, CLASS)}Info();
private final @{importedNames.get("string")} name = "@{submodule.getName}";
private final @{importedNames.get("string")} namespace = "@{submodule.getNamespace.toString}";
return INSTANCE;
}
- @{classBody(submodule, convertIdentifier(submodule.getName + "Info", CLASS))}
+ @{classBody(submodule, normalizeSpecificIdentifier(submodule.getName + "Info", CLASS))}
}
}
}
}
@if(!module.getSubmodules.isEmpty) {
@for(submodule <- module.getSubmodules) {
- set.add(@{convertIdentifier(submodule.getName, CLASS)}Info.getInstance());
+ set.add(@{normalizeSpecificIdentifier(submodule.getName, CLASS)}Info.getInstance());
}
}
@if(!module.getImports.isEmpty && !module.getSubmodules.isEmpty) {
Code Review / mdsal.git / commitdiff