@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); }