/** * Determines the symbolic name of the {@link EventDistributor} that will be created by this template * given the specified {@link ParameterResolver}. * * @param parameterResolver The {@link ParameterResolver} used to resolve parameters. * * @return The name of the {@link EventDistributor}. */ public String getDistributorName(ParameterResolver parameterResolver) { return m_exprDistributorName.evaluate(parameterResolver); }
/** * Required for {@link com.tangosol.io.ExternalizableLite} and {@link com.tangosol.io.pof.PortableObject}. */ public ParallelLocalCacheEventChannelBuilder() { super(); invocationServiceName = new LiteralExpression<String>(INVOCATION_SVC); }
@Override protected ParameterResolver initialValue() { return new NullParameterResolver(); } };
/** * {@inheritDoc} */ @Override public Dependencies realize(ParameterResolver parameterResolver, ClassLoader classLoader, ParameterList parameters) { String channelName = getChannelNameExpression().evaluate(parameterResolver); ScopedParameterResolver scopedResolver = new ScopedParameterResolver(parameterResolver); scopedResolver.add(new Parameter("channel-name", channelName)); String externalName = getExternalNameExpression().evaluate(scopedResolver); scopedResolver.add(new Parameter("channel-external-name", externalName)); return new DefaultDependencies(channelName, externalName, eventChannelBuilder, eventIteratorTransformerBuilder, startingMode, batchDistributionDelayMS, batchSize, restartDelay, totalConsecutiveFailuresBeforeSuspending, eventPollingDelayMS); } }
public NamedCache evaluate(ParameterResolver resolver) String sDesiredCacheName = new Value(m_exprCacheName.evaluate(resolver)).as(String.class); Parameter paramCacheName = resolver.resolve("cache-name"); String sCacheName = paramCacheName == null ? null : paramCacheName.evaluate(resolver).as(String.class);
ParameterList listParameters) String sBeanName = getBeanName().evaluate(resolver); Object oBean = ensureBeanFactory(resolver, loader).getBean(sBeanName); ParameterList listPropParams = listParameters == null ? m_listParameters : listParameters; Object oValue = param.evaluate(resolver).get(); String sProperty = param.getName();
/** * {@inheritDoc} */ @Override public Parameter process(ProcessingContext context, XmlElement element) throws ConfigurationException { String sName = context.getMandatoryProperty("name", String.class, element); try { return new Parameter(sName, context.getExpressionParser().parse(element.getString(), Object.class)); } catch (ParseException e) { throw new ConfigurationException("Error processing <property> element", "Ensure a valid value is present in <property> element", e); } } }
/** * Based on the known string expression and the * {@link ParameterResolver} create an instance of the destined * type. * * @param clzDestined the type of object parsing the string * should resolve * resolver the parameter resolver used by the * expression * @param <T> the instance type to return * * @return an instance of type {@link T} created from resolving * the string expression */ protected <T> T evaluate(Class<T> clzDestined, ParameterResolver resolver) { try { return m_exprParserCoh.parse(m_sExpression, clzDestined).evaluate(resolver); } catch (Throwable t) { } return null; } }
ParameterList parameterList) String externalName = m_exprDistributorExternalName.evaluate(parameterResolver); ScopedParameterResolver scopedResolver = new ScopedParameterResolver(parameterResolver); scopedResolver.add(new Parameter("distributor-name", distributor.getIdentifier().getSymbolicName())); scopedResolver.add(new Parameter("distributor-external-name", distributor.getIdentifier().getExternalName()));
public Object evaluate(ParameterResolver resolver) String sSchemeName = new Value(m_exprSchemeName.evaluate(resolver)).as(String.class); ServiceScheme scheme = m_registry.findSchemeBySchemeName(sSchemeName); Parameter paramClassLoader = resolver.resolve("class-loader"); ClassLoader classLoader = paramClassLoader == null ? Base.getContextClassLoader() : paramClassLoader.evaluate(resolver).as(ClassLoader.class); Parameter paramCacheName = resolver.resolve("cache-name"); String sCacheName = paramCacheName == null ? null : paramCacheName.evaluate(resolver).as(String.class); Parameter paramBMMC = resolver.resolve("manager-context"); BackingMapManagerContext bmmc = paramBMMC == null ? null : paramBMMC.evaluate(resolver).as(BackingMapManagerContext.class);
/** * Return the factory name produced by the provided expression, or * the name of the factory class if the expression is null. * * @param factoryClass the {@link Class} of the factory * (this will be used if no factory name was specified) * @param exprFactoryName the expression containing the {@link BeanFactory} name * @param resolver the {@link ParameterResolver} to use for resolving * factory names * * @return factory name for the {@link BeanFactory} */ protected static String getFactoryNameAsString(Class<?> factoryClass, Expression<String> exprFactoryName, ParameterResolver resolver) { return exprFactoryName == null ? factoryClass.getName() : exprFactoryName.evaluate(resolver); }
/** * {@inheritDoc} */ @Override public EventChannel realize(ParameterResolver parameterResolver, ClassLoader classLoader, ParameterList parameters) { return new CacheStoreEventChannel(contextCacheName.evaluate(parameterResolver), builder.realize(parameterResolver, classLoader, parameters)); }
/** * {@inheritDoc} */ @Override public EventChannel realize(ParameterResolver resolver, ClassLoader loader, ParameterList parameters) { return new BinaryEntryStoreEventChannel(contextCacheName.evaluate(resolver), builder.realize(resolver, loader, parameters)); }
/** * {@inheritDoc} */ @Override public EventChannel realize(ParameterResolver resolver, ClassLoader classLoader, ParameterList parameters) { String targetCacheName = getTargetCacheName().evaluate(resolver); return new LocalCacheEventChannel(targetCacheName, getConflictResolverBuilder()); }
/** * {@inheritDoc} */ @Override public EventChannel realize(ParameterResolver resolver, ClassLoader classLoader, ParameterList parameters) { return new RemoteCacheEventChannel(getDistributionRole(), getTargetCacheName().evaluate(resolver), getConflictResolverBuilder(), remoteCacheServiceName); }
/** * {@inheritDoc} */ @Override public boolean realizes(Class<?> clzClass, ParameterResolver resolver, ClassLoader loader) { String sBeanName = getBeanName().evaluate(resolver); BeanFactory factory = ensureBeanFactory(resolver, loader); if (factory.containsBean(sBeanName)) { return factory.isTypeMatch(sBeanName, clzClass); } else { String sFactory = getFactoryNameAsString(BeanFactory.class, getFactoryName(), resolver); StringBuilder sbProblem = new StringBuilder(); sbProblem.append("Spring bean '").append(sBeanName).append("' could not be loaded from bean factory '") .append(sFactory).append("' (").append(factory).append(")"); StringBuilder sbAdvice = new StringBuilder(); sbAdvice.append("Ensure that a bean name of '").append(sBeanName).append("' exists in bean factory '") .append(sFactory).append("'."); throw new ConfigurationException(sbProblem.toString(), sbAdvice.toString()); } }
/** * {@inheritDoc} */ @Override public EventChannel realize(ParameterResolver parameterResolver, ClassLoader classLoader, ParameterList parameters) { ResourceRegistry registry = CacheFactory.getConfigurableCacheFactory().getResourceRegistry(); String targetCacheName = getTargetCacheName().evaluate(parameterResolver); String invocationServiceName = getInvocationServiceName().evaluate(parameterResolver); LocalCacheEventChannelBuilder localEventChannelBuilder = new LocalCacheEventChannelBuilder(); localEventChannelBuilder.setConflictResolverBuilder(getConflictResolverBuilder()); localEventChannelBuilder.setTargetCacheName(getTargetCacheName()); return new ParallelLocalCacheEventChannel(targetCacheName, invocationServiceName, localEventChannelBuilder, registry, parameterResolver); }
String sAppCtx = exprAppCtxUri.evaluate(resolver); final URL url = Resources.findFileOrResource(sAppCtx, loader);