How to use

cast

method

in

java.lang.Class

  @Override
  public U apply(T t) throws Exception {
    return clazz.cast(t);
  }
}

static void checkCast(Class<?> clazz, Object obj) {
 clazz.cast(obj);
}

/**
 * Gets the most recent sticky event for the given type.
 *
 * @see #postSticky(Object)
 */
public <T> T getStickyEvent(Class<T> eventType) {
  synchronized (stickyEvents) {
    return eventType.cast(stickyEvents.get(eventType));
  }
}

/**
 * Remove and gets the recent sticky event for the given event type.
 *
 * @see #postSticky(Object)
 */
public <T> T removeStickyEvent(Class<T> eventType) {
  synchronized (stickyEvents) {
    return eventType.cast(stickyEvents.remove(eventType));
  }
}

private static <T> T newProxy(Class<T> interfaceType, InvocationHandler handler) {
 Object object =
   Proxy.newProxyInstance(
     interfaceType.getClassLoader(), new Class<?>[] {interfaceType}, handler);
 return interfaceType.cast(object);
}

/**
 * Returns the tag attached with {@code type} as a key, or null if no tag is attached with that
 * key.
 */
public @Nullable <T> T tag(Class<? extends T> type) {
 return type.cast(tags.get(type));
}

private static <T> T expectArgument(Class<T> type, Object arg) {
 try {
  return type.cast(arg);
 } catch (ClassCastException e) {
  throw new IllegalArgumentException(arg + " is not a " + type.getSimpleName());
 }
}

private static <T> T createEmptyArray(Class<T> arrayType) {
 return arrayType.cast(Array.newInstance(arrayType.getComponentType(), 0));
}

private static List<TypeElement> staticTypesIn(Iterable<? extends Element> elements) {
  List<TypeElement> list = new ArrayList<>();
  for (Element element : elements) {
    if (TYPE_KINDS.contains(element.getKind()) && element.getModifiers().contains(Modifier.STATIC)) {
      list.add(TypeElement.class.cast(element));
    }
  }
  return list;
}

@Override
public <A extends Annotation> @Nullable A getAnnotation(Class<A> annotationType) {
 checkNotNull(annotationType);
 for (Annotation annotation : annotations) {
  if (annotationType.isInstance(annotation)) {
   return annotationType.cast(annotation);
  }
 }
 return null;
}

  @Override
  protected <T> T lookup(String jndiName, Class<T> requiredType) throws NamingException {
    ++this.callCount;
    return requiredType.cast(DESTINATION);
  }
}

static <T extends Enum<T>> Optional<T> getEnumIfPresent(Class<T> enumClass, String value) {
 WeakReference<? extends Enum<?>> ref = Enums.getEnumConstants(enumClass).get(value);
 return ref == null ? Optional.<T>absent() : Optional.of(enumClass.cast(ref.get()));
}

 @Override
 public sun.misc.Unsafe run() throws Exception {
  Class<sun.misc.Unsafe> k = sun.misc.Unsafe.class;
  for (java.lang.reflect.Field f : k.getDeclaredFields()) {
   f.setAccessible(true);
   Object x = f.get(null);
   if (k.isInstance(x)) {
    return k.cast(x);
   }
  }
  throw new NoSuchFieldError("the Unsafe");
 }
});

private static <B, T extends B> T cast(Class<T> type, B value) {
 return Primitives.wrap(type).cast(value);
}

@CanIgnoreReturnValue
private static <B, T extends B> T cast(Class<T> type, B value) {
 return Primitives.wrap(type).cast(value);
}

@Nullable
final <T> T generateFresh(Class<T> type) {
 return Primitives.wrap(type).cast(generateFresh(TypeToken.of(type)));
}

  @Override
  protected <T> T lookup(String jndiName, Class<T> requiredType) {
    assertEquals(DATA_SOURCE_NAME, jndiName);
    return requiredType.cast(expectedDataSource);
  }
};

  @Override
  protected <T> T lookup(String jndiName, Class<T> requiredType) throws NamingException {
    if (called) {
      fail("Must not be delegating to lookup(..), must be resolving from cache.");
    }
    assertEquals(DESTINATION_NAME, jndiName);
    called = true;
    return requiredType.cast(DESTINATION);
  }
}

protected <T extends JCacheOperation<?>> T getCacheOperation(
    Class<T> operationType, Class<?> targetType, String methodName, Class<?>... parameterTypes) {
  JCacheOperation<?> result = getCacheOperation(targetType, methodName, parameterTypes);
  assertNotNull(result);
  assertEquals(operationType, result.getClass());
  return operationType.cast(result);
}

protected TextMessage createTextMessage(MessageCreator creator) throws JMSException {
  Session mock = mock(Session.class);
  given(mock.createTextMessage(BDDMockito.any())).willAnswer(
      (Answer<TextMessage>) invocation ->
          new StubTextMessage((String) invocation.getArguments()[0]));
  javax.jms.Message message = creator.createMessage(mock);
  verify(mock).createTextMessage(BDDMockito.any());
  return TextMessage.class.cast(message);
}