GenericType (essentials-shared 0.7.0 API)

java.lang.Object
- dk.cloudcreate.essentials.shared.types.GenericType<T>

Type Parameters:

T - the type provided to the GenericType
```
public abstract class GenericType<T>
extends Object
```
Using this class makes it possible to capture a generic/parameterized argument type, such as List<Money>, instead of having to rely on the classical .class construct.
When you specify a type reference using .class you loose any Generic/Parameterized information, as you cannot write List<Money>.class, only List.class.

With GenericType you can specify and capture parameterized type information

You can specify a parameterized type using GenericType:

var genericType = new GenericType<List<Money>>(){};

The type/getType() will return List.class
And genericType/getGenericType() will return ParameterizedType, which can be introspected further

You can also supply a non-parameterized type to GenericType:

var genericType = new GenericType<Money>(){};

In which case type/getType() will return Money.class
And genericType/getGenericType() will return Money.class

Field Summary

Fields
Modifier and Type Field Description

Type genericType

Class<T> type

Constructor Summary

Constructors
Constructor Description

GenericType()

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`Type`	`getGenericType()`
`Class<T>`	`getType()`
`static Optional<Class<?>>`	`resolveGenericType(Class<?> forType, int typeArgumentIndex)`	Resolve the concrete parameterized type a given `forType` has specified with its direct super class. Example: Given super-class: `class AggregateRoot<ID, AGGREGATE_TYPE extends AggregateRoot<ID, AGGREGATE_TYPE>> implements Aggregate<ID>` And sub/concrete class: `class Order extends AggregateRoot<OrderId, Order>`br> Then: `GenericType.resolveGenericType(Order.class, 0)` will return `OrderId.class` and `GenericType.resolveGenericType(Order.class, 1)` will return `Order.class`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - type
```
public final Class<T> type
```
  - genericType
```
public final Type genericType
```
- Constructor Detail
  - GenericType
```
public GenericType()
```
- Method Detail
  - resolveGenericType
```
public static Optional<Class<?>> resolveGenericType(Class<?> forType,
                                                    int typeArgumentIndex)
```
    Resolve the concrete parameterized type a given forType has specified with its direct super class.
    Example:
    Given super-class:
    class AggregateRoot<ID, AGGREGATE_TYPE extends AggregateRoot<ID, AGGREGATE_TYPE>> implements Aggregate<ID>
    
    And sub/concrete class:
    class Order extends AggregateRoot<OrderId, Order>br>
    Then:
    GenericType.resolveGenericType(Order.class, 0) will return OrderId.class
    
    and
    GenericType.resolveGenericType(Order.class, 1) will return Order.class
    
    Parameters:
    
    forType - the type that is specifying a parameterized type with its super-class
    
    typeArgumentIndex - the index in the superclasses type parameters (0 based)
    
    Returns:
    
    an optional with the parameterized type or Optional.empty() if the type couldn't resolved
  - getType
```
public Class<T> getType()
```
  - getGenericType
```
public Type getGenericType()
```