From a980583d2bfb82914e8c3200d5ad9a1f5c66aae4 Mon Sep 17 00:00:00 2001
From: Sameeksha Vaity <savaity@microsoft.com>
Date: Wed, 20 Oct 2021 13:23:47 -0700
Subject: [PATCH] Expose class information for TypeReference<T> (#24568)

---
 sdk/core/azure-core/CHANGELOG.md              |  1 +
 .../core/util/serializer/TypeReference.java   | 15 ++++++++
 .../util/serializer/TypeReferenceTests.java   | 38 +++++++++++++++++++
 3 files changed, 54 insertions(+)
 create mode 100644 sdk/core/azure-core/src/test/java/com/azure/core/util/serializer/TypeReferenceTests.java

diff --git a/sdk/core/azure-core/CHANGELOG.md b/sdk/core/azure-core/CHANGELOG.md
index 16879a81f0c2..5af363fa32dc 100644
--- a/sdk/core/azure-core/CHANGELOG.md
+++ b/sdk/core/azure-core/CHANGELOG.md
@@ -3,6 +3,7 @@
 ## 1.22.0-beta.2 (Unreleased)
 
 ### Features Added
+- Added `getJavaClass` method to retrieve the representing instance of the `TypeReference` created.
 
 ### Breaking Changes
 
diff --git a/sdk/core/azure-core/src/main/java/com/azure/core/util/serializer/TypeReference.java b/sdk/core/azure-core/src/main/java/com/azure/core/util/serializer/TypeReference.java
index cc1b3b64fbb5..6e1f6eb30ca6 100644
--- a/sdk/core/azure-core/src/main/java/com/azure/core/util/serializer/TypeReference.java
+++ b/sdk/core/azure-core/src/main/java/com/azure/core/util/serializer/TypeReference.java
@@ -3,6 +3,7 @@
 
 package com.azure.core.util.serializer;
 
+import com.azure.core.implementation.TypeUtil;
 import com.azure.core.util.logging.ClientLogger;
 
 import java.lang.reflect.ParameterizedType;
@@ -41,12 +42,14 @@ public abstract class TypeReference<T> {
     private static final Map<Class<?>, TypeReference<?>> CACHE = new ConcurrentHashMap<>();
 
     private final Type javaType;
+    private final Class<T> clazz;
 
     /**
      * Constructs a new {@link TypeReference} which maintains generic information.
      *
      * @throws IllegalArgumentException If the reference is constructed without type information.
      */
+    @SuppressWarnings("unchecked")
     public TypeReference() {
         Type superClass = this.getClass().getGenericSuperclass();
         if (superClass instanceof Class) {
@@ -54,10 +57,12 @@ public TypeReference() {
         } else {
             this.javaType = ((ParameterizedType) superClass).getActualTypeArguments()[0];
         }
+        this.clazz = (Class<T>) TypeUtil.getRawClass(javaType);
     }
 
     private TypeReference(Class<T> clazz) {
         this.javaType = clazz;
+        this.clazz = clazz;
     }
 
     /**
@@ -88,4 +93,14 @@ public static <T> TypeReference<T> createInstance(Class<T> clazz) {
          */
         return (TypeReference<T>) CACHE.computeIfAbsent(clazz, c -> new TypeReference<T>(clazz) { });
     }
+
+    /**
+     * Returns the {@link Class} representing instance of the {@link TypeReference} created.
+     *
+     * @return The {@link Class} representing instance of the {@link TypeReference} created
+     * using the {@link TypeReference#createInstance(Class)}, otherwise returns {@code null}.
+     */
+    public Class<T> getJavaClass() {
+        return this.clazz;
+    }
 }
diff --git a/sdk/core/azure-core/src/test/java/com/azure/core/util/serializer/TypeReferenceTests.java b/sdk/core/azure-core/src/test/java/com/azure/core/util/serializer/TypeReferenceTests.java
new file mode 100644
index 000000000000..92a46b47b022
--- /dev/null
+++ b/sdk/core/azure-core/src/test/java/com/azure/core/util/serializer/TypeReferenceTests.java
@@ -0,0 +1,38 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package com.azure.core.util.serializer;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class TypeReferenceTests {
+
+    @Test
+    public void createGenericTypeReference() {
+        final TypeReference<HashMap<String, Object>> typeReference = new TypeReference<HashMap<String, Object>>() { };
+        final Map<String, Object> expectedJavaType = new HashMap<String, Object>() { };
+        assertEquals(expectedJavaType.getClass().getGenericSuperclass(), typeReference.getJavaType());
+        assertEquals(HashMap.class, typeReference.getJavaClass());
+    }
+
+    @Test
+    public void createFactoryInstance() {
+        TypeReference<Integer> typeReference = TypeReference.createInstance(int.class);
+        assertEquals(int.class, typeReference.getJavaType());
+        assertEquals(int.class, typeReference.getJavaClass());
+    }
+
+    @SuppressWarnings("rawtypes")
+    @Test
+    public void createTypeReferenceWithoutType() {
+        IllegalArgumentException thrown
+            = assertThrows(IllegalArgumentException.class, () -> new TypeReference() { });
+        assertEquals("Type constructed without type information.", thrown.getMessage());
+    }
+}