CLDR-15830 Refactor/simplify NameType

[btangmu]

-Remove getNameName, getNameTypeName, String[][] NameTable, INDEX_LANGUAGE, ..., nameTableIndex, fromNameTableIndex

-Associate the enum values with the corresponding path fragments by means of constructors

-Move FIX_KEY_NAME, fixKeyName from CLDRFile to NameType

-New method NameType.toCodeType converts NameType to CodeType and obviates conversion to/from String as intermediate step

-Comments

CLDR-15830

• This PR completes the ticket.

ALLOW_MANY_COMMITS=true

[srl295]

great refactor

[macchiati]

Just one item, otherwise looks great.

[macchiati]

Better to make the related enum values be elements of the other one.

That is, CodeType would have a field set from its private constructor:

final NameType nameType;

Then toNameType becomes:

public NameType toNameType() {
  return nameType;
}

Similarly, NameType would have a field set from its private constructor:

final CodeType codeType;

Then fromNameType moves to be a method NameType.toCodeType.

public CodeType toNameType() {
  if (codeType == null) {
    throw new IllegalArgumentException("Unsupported name type");
  }
  return codeType;
}

[btangmu]

good idea, I'll make that change

[btangmu]

@macchiati I thought it was a great idea, but it failed due to the sequence of initialization. If NameType constructor references CodeType, and CodeType constructor references NameType, one or the other will get null values.

See https://stackoverflow.com/questions/1506410/java-enums-two-enum-types-each-containing-references-to-each-other which suggests various workarounds, but they're all kind of ugly.

Instead I just made it a little more symmetrical by implementing NameType.toCodeType instead of CodeType.fromNameType.

Maybe there's still a more elegant or efficient way; I suggest leaving that for a follow-up PR if and when it seems worthwhile to pursue.

[macchiati]

I've done it with something like the following, to avoid switches. However, I think your solution is good enough.

	
	enum Bar {D(Foo.a), E(Foo.b), F(Foo.c);
		
		private Foo foo;
		
		private Bar(Foo foo) {
			this.foo = foo;
		}
		
		public Foo toFoo() {
			return foo;
		}
		
		private static Map<Foo, Bar> BACKMAP = Arrays.stream(Bar.values())
                          .collect(Collectors.toUnmodifiableMap(bar -> bar.foo, bar -> bar));
		
		public static Bar fromFoo(Foo foo) {
			return BACKMAP.get(foo);
		}
	}

	private static void checkFooBar() {
		Arrays.stream(Foo.values()).forEach(foo -> {
			Bar bar = Bar.fromFoo(foo);
			Foo foo2 = bar.toFoo();
			System.out.println(foo + "\t" + bar + "\t" + foo2);
			});
	}