Ad an entry to the list of {@link RuleProvider} classes that should execute after the {@link Rule} instances in the corresponding
{@link RuleProvider} instance.

{@link RuleProvider}s can also be specified based on id ({@link #getExecuteBeforeIDs}).
356278
public MetadataBuilder addExecuteAfter(Class<? extends RuleProvider> type)
    {
        if (type != null)
        {
            executeAfter.add(type);
        }
        return this;
    }
466217
protected void executeExecutionListeners(HasExecutionListeners elementWithExecutionListeners,
      ExecutionEntity executionEntity, String eventType) {
    commandContext.getProcessEngineConfiguration().getListenerNotificationHelper()
      .executeExecutionListeners(elementWithExecutionListeners, executionEntity, eventType);
  }
126311
public void setProviders(Object... theProviders) {
		Validate.noNullElements(theProviders, "theProviders must not contain any null elements");

		myPlainProviders.clear();
		if (theProviders != null) {
			myPlainProviders.addAll(Arrays.asList(theProviders));
		}
	}
378093
private void processDataProvider(final DataProvider<RI> dataProvider) {
        // Get rules matching the data provider
        final List<Rule<RI, RO>> mappedRules = dataProvidersToRules.get(dataProvider);
        if ((mappedRules == null) || mappedRules.isEmpty()) {
            LOGGER.warn("No matching rule in mappable validator for data provider: " + dataProvider);
        } else {
            // Get data to be validated
            final RI data = dataProvider.getData();

            // Process all matching rules
            for (final Rule<RI, RO> rule : mappedRules) {
                processRule(rule, data);
            }
        }
    }
1371017
public void execute() {
        OrderComparator.sortIfNecessary(webflowConfigurers);
        webflowConfigurers.forEach(c -> {
            LOGGER.trace("Registering webflow configurer [{}]", c.getName());
            c.initialize();
        });
    }
196907
public void addRuleParserAfter(IRuleParser parser, Class<? extends IRuleParser> afterParser) {
        int index = getIndexOfClass(ruleParsers, afterParser);
        if (index == -1) {
            throw new ParserAddException("parser " + afterParser.getSimpleName() + " has not been added");
        }
        ruleParsers.add(index + 1, parser);
    }
1342965
public void executeBeforeClass(@Observes BeforeClass event, TestClass testClass) throws Exception{
		testClass = event.getTestClass();

		//1. Check whether the annotation is present at the class level
		if (testClass.isAnnotationPresent(Mediaserver.class)) {
			isMediaserverAnnotationPresentClass = true;
		}

		//2. Check whether the annotation is present at one of the fields
		Field[] fields = testClass.getJavaClass().getDeclaredFields();
		for (Field field : fields) {
			if (field.isAnnotationPresent(Mediaserver.class)){
				if (field.getType().isAssignableFrom(EmbeddedMediaserver.class)){
					isMediaserverAnnotationPresentField = true;
					deployableServerFields.add(field);
				}
			}
		}
		//3. Check whether the annotation is present at the test method level
		Method[] methods = testClass.getMethods(Mediaserver.class); 
		for (Method method : methods) {
			if (method.isAnnotationPresent(Mediaserver.class)){
				isMediaserverAnnotationPresentMethod = true;
				deployableServerMethods.add(method);
			}
		}

		if(deployableServerFields.size()>1)
			throw new EmbeddedMediaserverException("MediaServer annotation specified many times!");

		//Mediaserver annotation must be defined in only one place
		if (isMediaserverAnnotationPresentField && (isMediaserverAnnotationPresentClass || isMediaserverAnnotationPresentMethod)
				|| (isMediaserverAnnotationPresentClass && isMediaserverAnnotationPresentMethod)){
			throw new EmbeddedMediaserverException("MediaServer annotation specified many times!");
		}

		//If the annotation is defined in the Class level, the start the server
		if (isMediaserverAnnotationPresentClass)
			startAndConfigureServer(testClass.getAnnotation(Mediaserver.class));

	}
780707
@EachBean(DataSource.class)
    DataSourceTransactionManager dataSourceTransactionManager(
            DataSource dataSource) {
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager(dataSource);
        dataSourceTransactionManager.afterPropertiesSet();
        return dataSourceTransactionManager;
    }
1149704
@Override
    @SuppressWarnings("unchecked")
    public Class<ValidationProvider<?>> getDefaultProviderClass() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "getDefaultProviderClass");
        }
        Class<ValidationProvider<?>> clazz = null;

        if (defaultProvider != null) {
            // default provider is specified so get a class to it.
            String provider = defaultProvider;
            // load the class for the provider
            try {
                clazz = (Class<ValidationProvider<?>>) loadClass(provider);
            } catch (Throwable t) {
                FFDCFilter.processException(t, CLASS_NAME + ".getDefaultProvider", "217");

                // message and exception printed out in previous method called.
                // however since we can not create a validation factory throw validationException
                ValidationException e = new ValidationException(t);
                throw e;
            }
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "getDefaultProviderClass", clazz);
        }
        return clazz;
    }
454969
public ResultHandlerContext<D, O> check(final Rule<D, O>... rules) {
        if (rules != null) {
            Collections.addAll(registeredRules, rules);
        }
        return this;
    }
432351
public void executeOnEntriesInternal(EntryProcessor entryProcessor, Predicate predicate, List<Data> result) {
        try {
            Map<Integer, Object> results;
            if (predicate instanceof PartitionPredicate) {
                PartitionPredicate partitionPredicate = (PartitionPredicate) predicate;
                Data key = toData(partitionPredicate.getPartitionKey());
                int partitionId = partitionService.getPartitionId(key);
                handleHazelcastInstanceAwareParams(partitionPredicate.getTarget());

                OperationFactory operation = operationProvider.createPartitionWideEntryWithPredicateOperationFactory(
                        name, entryProcessor, partitionPredicate.getTarget());
                results = operationService.invokeOnPartitions(SERVICE_NAME, operation, singletonList(partitionId));
            } else {
                OperationFactory operation = operationProvider.createPartitionWideEntryWithPredicateOperationFactory(
                        name, entryProcessor, predicate);
                results = operationService.invokeOnAllPartitions(SERVICE_NAME, operation);
            }
            for (Object object : results.values()) {
                if (object != null) {
                    MapEntries mapEntries = (MapEntries) object;
                    for (int i = 0; i < mapEntries.size(); i++) {
                        result.add(mapEntries.getKey(i));
                        result.add(mapEntries.getValue(i));
                    }
                }
            }
        } catch (Throwable t) {
            throw rethrow(t);
        }
    }
432486
public T getProvider(final String id) {
        return (T) beanFactory.getBean(providerFactory.beanName(id));
    }
336906
@Override
    public void afterPropertiesSet() throws Exception {
        final Map<String, Set<String>> resultAttributeMapping = this.getResultAttributeMapping();
        if (this.setReturningAttributes && resultAttributeMapping != null) {
            this.searchControls.setReturningAttributes(resultAttributeMapping.keySet().toArray(new String[resultAttributeMapping.size()]));
        }

        if (this.contextSource == null) {
            throw new BeanCreationException("contextSource must be set");
        }
    }
433843
@Override
    public void execute() {
        Set<String> annotated = db.getAnnotationIndex().get(Audit.class.getName());
        ScanAnnotatedFilter filter = new ScanAnnotatedFilter();
        for (String annotaionClass : annotated) {
            try {
                Class<?> clazz = Class.forName(annotaionClass);
                filter.addClass(clazz);
            } catch (ClassNotFoundException e) {
                throw new InitializationException("", e);
            }
        }
        PreConfigurationContext.addAnnotationFilter(filter);
    }
876631
public List<Rule> getRules(RuleProvider provider)
    {
        List<Rule> rules = providersToRules.get(provider);
        if (rules == null)
        {
            return Collections.emptyList();
        }
        return Collections.unmodifiableList(rules);
    }
564783
public void doInvocationCollaboratorsPreInvoke(IInvocationCollaborator[] webAppInvocationCollaborators,
            com.ibm.wsspi.webcontainer.metadata.WebComponentMetaData cmd) {

    }
228180
private void getEJBWithProviderClasses(Set<String> classeNames, EJBEndpoint ejb, String ejbInterfaceName, ClassLoader appClassloader) {
        final String methodName = "getEJBWithProviderClasses";
        if (tc.isEntryEnabled())
            Tr.entry(tc, methodName, classeNames, ejb, ejbInterfaceName);

        if (classeNames == null) {
            if (tc.isEntryEnabled())
                Tr.exit(tc, methodName, Collections.emptySet());
            return;
        }

        Class<Provider> providerClass = Provider.class;
        final String ejbClassName = (ejbInterfaceName == null) ? ejb.getClassName() : ejbInterfaceName;
        Class<?> c = null;
        try {
            c = appClassloader.loadClass(ejbClassName);
        } catch (ClassNotFoundException e) {

//            if (tc.isDebugEnabled()) {
//                Tr.debug(tc, "getEJBWithProviderClasses() exit - due to Class Not Found for " + ejbClassName + ": " + e);
//            }
            Tr.error(tc, "error.failed.toloadejbclass", ejbClassName);
        }

        if (c != null && c.getAnnotation(providerClass) != null) {
            classeNames.add(ejbClassName);
        }

        if (tc.isEntryEnabled())
            Tr.exit(tc, methodName, classeNames);
    }