public static boolean areAssignable(Class<?>[] types, Object[] values) { if (types.length != values.length) { return false; } for (int i = 0; i < values.length; i++) { Object val = values[i]; if (val != null && !instanceOf(val, types[i])) { return false; } } return true; }
@Override public synchronized boolean remove(Object bean) { boolean removedProvided = state.providedInstances.remove(bean); boolean removedInstance = state.instances.remove(bean); boolean removed = removedProvided || removedInstance; if (removed) { Class<?> clazz = bean.getClass(); state.providedClasses.remove(clazz); metadata.remove(clazz); for (Map.Entry<Class<?>, Set<Object>> e : state.providersByType.entrySet()) { e.getValue().removeIf(provider -> Cls.instanceOf(provider, bean.getClass())); } } return removed; }
@SuppressWarnings("unchecked") public static <T> T getUniqueInstanceOf(Class<T> type, Collection<?> values) { T instance = null; for (Object obj : values) { if (instanceOf(obj, type)) { if (instance == null) { instance = (T) obj; } else { throw U.rte("Found more than one instance of %s: %s and %s", type, instance, obj); } } } return instance; }
protected boolean isSimpleContent(Object content) { if (content instanceof Var) { Var<?> var = (Var<?>) content; return isSimpleContent(var.get()); } if (content instanceof ConstantTag) { return true; } return !Cls.instanceOf(content, Tag.class, CustomTag.class, TagWidget.class, Object[].class, Collection.class); }
private <T> T as(Class<T> type) { U.must(Cls.instanceOf(target, type), "Expected a type '%s', but found: %s", type, target); return U.cast(target); }
@Override public boolean fitsIn(Item item) { return super.fitsIn(item) && (beanType == null || Cls.instanceOf(item.value(), beanType)); }
@SuppressWarnings("unchecked") @Override public void onDone(Channel conn, Object tag) { assert Cls.instanceOf(tag, exchangeType); if (useExchangePool) { pool(conn.helper()).release((T) tag); } }
@Override public void process(Channel ctx) { T exchange = useExchangePool ? pool(ctx.helper()).get() : Cls.newInstance(exchangeType); assert Cls.instanceOf(exchange, exchangeType); exchange.reset(); exchange.setConnection(ctx); process(ctx, exchange); }
@Override public synchronized boolean remove(Object bean) { boolean removedProvided = state.providedInstances.remove(bean); boolean removedInstance = state.instances.remove(bean); boolean removed = removedProvided || removedInstance; if (removed) { Class<?> clazz = bean.getClass(); state.providedClasses.remove(clazz); metadata.remove(clazz); for (Map.Entry<Class<?>, Set<Object>> e : state.providersByType.entrySet()) { Iterator<Object> it = e.getValue().iterator(); while (it.hasNext()) { Object provider = it.next(); if (Cls.instanceOf(provider, bean.getClass())) { it.remove(); } } } } return removed; }
@SuppressWarnings("unchecked") @Override public void onDone(Channel conn, Object tag) { assert Cls.instanceOf(tag, exchangeType); pool(conn.helper()).release((T) tag); }
@Override public void process(Channel ctx) { T exchange = pool(ctx.helper()).get(); assert Cls.instanceOf(exchange, exchangeType); exchange.reset(); exchange.setConnection(ctx); Ctxs.open("x-request"); try { Ctxs.ctx().setExchange(exchange); process(ctx, exchange); } finally { Ctxs.close(); } }