# Type Token Generic

static class TypeSaftyMap {
  Map <Class<?>, Object> map = new HashMap<>();

  <T> void put(Class<T> clazz, T value) {
    map.put(clazz, value);
  }

  <T> get(Class<T> clazz) {
    return clazz.cast(map.get(clazz));
  }
}

TypeSaftyMap map = new TypeSaftyMap();

map.put(String.class, "String");
map.put(Integer.class, 3);
map.put(List.class, Arrays.asList(1, 2, 3));

System.out.println(String.class);
System.out.println(Integer.class);
System.out.println(List.class);

List<String> list = new ArrayList<>();

ArrayList list = new ArrayList();

map.put(List.class, Arrays.asList(1, 2, 3));
map.put(List.class, Arrays.asList("1", "2", "3"));

map.put(List<Integer>.class, Arrays.asList(1, 2, 3));
map.put(List<String>.class, Arrays.asList("1", "2", "3"));

// 제네릭 부모 클래스
class Parent<T> {
  T value;
}

// 정적으로 정의된 부모를 상속하는 서브 클래스
class Child extends Parent<String> {
  ...
}

Child child = new Child();

// 부모의 제네릭 클래스 정보를 얻음
Type type = child.getClass().getGenericSuperclass();

// 타입으로부터 파라메터 타입을 다시 얻음
ParameterizedType paramType = (ParameterizedType) type;

// 파라메터 타입의 인자를 확인하면 그 안에 제네릭 타입이 들어있음
System.out.println(paramType.getActualTypeArguments()[0]);  // String

abstract class TypeReference<T> {
  Type type;

  public TypeReference() {
    Type parentType = getClass.getGenericSuperclass();
    this.type = ((ParameterizedType) parentType).getActualTypeArguments()[0];
  }
}

class TypeSaftyMap {
  Map<TypeReference<?>, Object> map = new HashMap<>();

  <T> void put(TypeReference<T> tRef, T value) {
    map.put(tRef, value);
  }

  <T> get(TypeReference<T> tRef) {
    return ((Class<T>) tRef.type).cast(map.get(tRef));
  }
}

abstract class TypeReference<T> {
  Type type;

  public TypeReference() {
      Type parentType = getClass().getGenericSuperclass();

      if (parentType instanceof ParameterizedType) {
          this.type = ((ParameterizedType) parentType).getActualTypeArguments()[0];
      } else throw new RuntimeException();
  }

  public int hashCode() {
      return type.hashCode();
  }

  public boolean equals(Object obj) {
      if (this == obj) return true;
      if (obj == null || getClass().getSuperclass() != obj.getClass().getSuperclass()) return false;

      TypeReference<?> that = (TypeReference<?>) obj;

      return type.equals(that.type);
  }

  public String toString() {
      return type.getTypeName();
  }
}

TypeSaftyMap map = new TypeSaftyMap();
map.put(new TypeReference<Integer>(){}, 3);
map.put(new TypeReference<String>(){}, "ABC");

// java.lang.Integer
System.out.println(new TypeReference<Integer>(){});

// java.lang.String
System.out.println(new TypeReference<String>(){});

// 3
System.out.println(map.get(new TypeReference<Integer>(){}));
// ABC
System.out.println(map.get(new TypeReference<String>(){}));

//에러발생
System.out.println(map.get(new TypeReference<List<Integer>>(){}));
//에러발생
System.out.println(map.get(new TypeReference<List<String>>(){}));

class TypeSaftyMap {
  Map<TypeReference<?>, Object> map = new HashMap<>();

  <T> void put(TypeReference<T> typeRef, T value) {
    map.put(typeRef, value);
  }

  <T> get(TypeReference<T> typeRef) {
    // 일반 클래스
    if (typeRef.type instanceof Class<?>) {
      return ((Class<T>) typeRef).cast(map.get(typeRef));
    } else {
      return ((Class<T>) ((ParameterizedType) typeRef.type).getRawType()).case(map.get(typeRef));
    }
  }
}

TypeSaftyMap map = new TypeSaftyMap();
map.put(new TypeReference<List<Integer>>(){}, Array.asList(1,2,3));
map.put(new TypeReference<List<String>>(){}, Array.asList("a","b","c"));

//[1,2,3]
System.out.println(map.get(new TypeReference<List<Integer>>(){}));
//["a","b","c"]
System.out.println(map.get(new TypeReference<List<String>>(){}));