public ClientConfigurableImpl(C configurable, Configuration config) { super(configurable, config == null ? new ConfigurationImpl(RuntimeType.CLIENT) : new ConfigurationImpl(config)); } }
@Override public boolean isRegistered(Class<?> cls) { for (Object o : getInstances()) { if (cls == o.getClass()) { return true; } } return false; }
private void register(Object provider, int bindingPriority, Class<?>... contracts) { register(provider, initContractsMap(bindingPriority, contracts)); }
public boolean register(Object provider, Map<Class<?>, Integer> contracts) { if (provider.getClass() == Class.class) { if (isRegistered((Class<?>)provider)) { LOG.warning("Provider class " + ((Class<?>)provider).getName() + " has already been registered"); return false; } provider = createProvider((Class<?>)provider); } if (isRegistered(provider)) { LOG.warning("Provider " + provider.getClass().getName() + " has already been registered"); return false; } if (!contractsValid(provider, contracts)) { return false; } Map<Class<?>, Integer> metadata = providers.get(provider); if (metadata == null) { metadata = new HashMap<>(); providers.put(provider, metadata); } for (Entry<Class<?>, Integer> entry : contracts.entrySet()) { if (entry.getKey().isAssignableFrom(provider.getClass())) { metadata.put(entry.getKey(), entry.getValue()); } } return true; }
public ConfigurationImpl(Configuration parent) { if (parent != null) { this.props.putAll(parent.getProperties()); this.runtimeType = parent.getRuntimeType(); Set<Class<?>> providerClasses = new HashSet<>(parent.getClasses()); for (Object o : parent.getInstances()) { if (!(o instanceof Feature)) { registerParentProvider(o, parent); } else { Feature f = (Feature)o; features.put(f, parent.isEnabled(f)); } providerClasses.remove(o.getClass()); } for (Class<?> cls : providerClasses) { registerParentProvider(createProvider(cls), parent); } } }
@Override public <T> Object create(Class<T> cls) { final Set<Bean<?>> candidates = beanManager.getBeans(cls); final Bean<?> bean = beanManager.resolve(candidates); if (bean != null) { final CreationalContext<?> context = beanManager.createCreationalContext(bean); if (!beanManager.isNormalScope(bean.getScope())) { beanManager.fireEvent(new DisposableCreationalContext(context)); } return beanManager.getReference(bean, cls, context); } else { // No CDI bean available, falling back to default instantiation strategy return ConfigurationImpl.createProvider(cls); } } }
private C doRegister(Object provider, Map<Class<?>, Integer> contracts) { if (!checkConstraints(provider)) { return configurable; } if (provider instanceof Feature) { Feature feature = (Feature)provider; boolean enabled = feature.configure(new FeatureContextImpl(this)); config.setFeature(feature, enabled); return configurable; } config.register(provider, contracts); return configurable; }
private C doRegister(Object provider, int bindingPriority, Class<?>... contracts) { if (contracts == null || contracts.length == 0) { LOG.warning("Null, empty or invalid contracts specified for " + provider + "; ignoring."); return configurable; } return doRegister(provider, ConfigurationImpl.initContractsMap(bindingPriority, contracts)); }
private void registerParentProvider(Object o, Configuration parent) { Map<Class<?>, Integer> contracts = parent.getContracts(o.getClass()); if (contracts != null) { providers.put(o, contracts); } else { register(o, AnnotationUtils.getBindingPriority(o.getClass()), ConfigurableImpl.getImplementedContracts(o, new Class<?>[]{})); } }
private boolean checkConstraints(Object provider) { Class<?> providerClass = provider.getClass(); ConstrainedTo providerConstraint = providerClass.getAnnotation(ConstrainedTo.class); if (providerConstraint != null) { RuntimeType currentRuntime = config.getRuntimeType(); RuntimeType providerRuntime = providerConstraint.value(); // need to check (1) whether the registration is occurring in the specified runtime type // and (2) does the provider implement an invalid interface based on the constrained runtime type if (!providerRuntime.equals(currentRuntime)) { LOG.warning("Provider " + provider + " cannot be registered in this " + currentRuntime + " runtime because it is constrained to " + providerRuntime + " runtimes."); return false; } Class<?>[] restrictedInterfaces = RuntimeType.CLIENT.equals(providerRuntime) ? RESTRICTED_CLASSES_IN_CLIENT : RESTRICTED_CLASSES_IN_SERVER; for (Class<?> restrictedContract : restrictedInterfaces) { if (restrictedContract.isAssignableFrom(providerClass)) { RuntimeType opposite = RuntimeType.CLIENT.equals(providerRuntime) ? RuntimeType.SERVER : RuntimeType.CLIENT; LOG.warning("Provider " + providerClass.getName() + " is invalid - it is constrained to " + providerRuntime + " runtimes but implements a " + opposite + " interface "); return false; } } } return true; }
@Override public <T> Object create(Class<T> cls) { final Set<Bean<?>> candidates = beanManager.getBeans(cls); final Bean<?> bean = beanManager.resolve(candidates); if (bean != null) { final CreationalContext<?> context = beanManager.createCreationalContext(bean); if (!beanManager.isNormalScope(bean.getScope())) { beanManager.fireEvent(new DisposableCreationalContext(context)); } return beanManager.getReference(bean, cls, context); } else { // No CDI bean available, falling back to default instantiation strategy return ConfigurationImpl.createProvider(cls); } } }
public ClientConfigurableImpl(C configurable, Configuration config) { super(configurable, config == null ? new ConfigurationImpl(RuntimeType.CLIENT) : new ConfigurationImpl(config)); } }
@Override public boolean isRegistered(Object obj) { for (Object o : getInstances()) { if (o.equals(obj)) { return true; } } return false; }
public MicroProfileClientConfigurableImpl(C configurable, Configuration config) { super(configurable, config == null ? new ConfigurationImpl(RuntimeType.CLIENT) : new ConfigurationImpl(config)); }
@Override public Set<Class<?>> getClasses() { Set<Class<?>> classes = new HashSet<>(); for (Object o : getInstances()) { classes.add(o.getClass()); } return classes; }
public ConfigurableImpl(C configurable, RuntimeType rt) { this(configurable, new ConfigurationImpl(rt)); }
@Override public Map<Class<?>, Integer> getContracts(Class<?> cls) { for (Object o : getInstances()) { if (cls.isAssignableFrom(o.getClass())) { if (o instanceof Feature) { return Collections.emptyMap(); } else { return providers.get(o); } } } return Collections.emptyMap(); }
public MicroProfileClientConfigurableImpl(C configurable, Configuration config) { super(configurable, config == null ? new ConfigurationImpl(RuntimeType.CLIENT) : new ConfigurationImpl(config)); }
public ConfigurableImpl(C configurable, Configuration config) { this.configurable = configurable; this.config = config instanceof ConfigurationImpl ? (ConfigurationImpl)config : new ConfigurationImpl(config); this.classLoader = Thread.currentThread().getContextClassLoader(); restrictedContractTypes = RuntimeType.CLIENT.equals(config.getRuntimeType()) ? RESTRICTED_CLASSES_IN_CLIENT : RESTRICTED_CLASSES_IN_SERVER; }