Gets role descriptor resolver.

@param resolver       the resolver
@param context        the context
@param profileRequest the profile request
@return the role descriptor resolver
@throws Exception the exception
497357
protected RoleDescriptorResolver getRoleDescriptorResolver(final MetadataResolver resolver,
                                                               final MessageContext context,
                                                               final RequestAbstractType profileRequest) throws Exception {
        val idp = casProperties.getAuthn().getSamlIdp();
        return SamlIdPUtils.getRoleDescriptorResolver(resolver, idp.getMetadata().isRequireValidMetadata());
    }
785513
@Override
    public void setEntityResolver(EntityResolver resolver) {
        if (resolver instanceof EntityResolver2) {
            resolver2 = (EntityResolver2) resolver;
        } else {
            resolver2 = null;
        }
        if (resolver == null) {
            resolver = base;
        }
        entityResolver = resolver;
    }
623131
public static RoleDescriptorResolver getRoleDescriptorResolver(final MetadataResolver metadata,
                                                                   final boolean requireValidMetadata) throws Exception {
        val roleDescriptorResolver = new PredicateRoleDescriptorResolver(metadata);
        roleDescriptorResolver.setSatisfyAnyPredicates(true);
        roleDescriptorResolver.setUseDefaultPredicateRegistry(true);
        roleDescriptorResolver.setRequireValidMetadata(requireValidMetadata);
        roleDescriptorResolver.initialize();
        return roleDescriptorResolver;
    }
847498
protected Service resolveServiceFromAuthenticationRequest(final RequestContext context) {
        val ctxService = WebUtils.getService(context);
        return resolveServiceFromAuthenticationRequest(ctxService);
    }
407613
public static JournalReader getInstance(Map<String, String> parameters,
                                            String role,
                                            JournalRecoveryLog recoveryLog,
                                            ServerInterface server)
            throws ModuleInitializationException {

        try {
            Object journalReader =
                    JournalHelper
                            .createInstanceAccordingToParameter(PARAMETER_JOURNAL_READER_CLASSNAME,
                                                                new Class[] {
                                                                        Map.class,
                                                                        String.class,
                                                                        JournalRecoveryLog.class,
                                                                        ServerInterface.class},
                                                                new Object[] {
                                                                        parameters,
                                                                        role,
                                                                        recoveryLog,
                                                                        server},
                                                                parameters);
            logger.info("JournalReader is " + journalReader.toString());
            return (JournalReader) journalReader;
        } catch (JournalException e) {
            String msg = "Can't create JournalReader";
            logger.error(msg, e);
            throw new ModuleInitializationException(msg, role, e);
        }
    }
1299338
private MavenArtifactDescriptor getMavenArtifactDescriptor(Dependency dependency, ScannerContext context) {
        DependencyCoordinates coordinates = new DependencyCoordinates(dependency);
        return getArtifactResolver(context).resolve(coordinates, context);
    }
1246776
private static ServiceProviderFinder _getServiceProviderFinderFromInitParam(ExternalContext context)
    {
        String initializerClassName = context.getInitParameter(SERVICE_PROVIDER_FINDER_PARAM);
        if (initializerClassName != null)
        {
            try
            {
                // get Class object
                Class<?> clazz = ClassUtils.classForName(initializerClassName);
                if (!ServiceProviderFinder.class.isAssignableFrom(clazz))
                {
                    throw new FacesException("Class " + clazz 
                            + " does not implement ServiceProviderFinder");
                }
                
                // create instance and return it
                return (ServiceProviderFinder) ClassUtils.newInstance(clazz);
            }
            catch (ClassNotFoundException cnfe)
            {
                throw new FacesException("Could not find class of specified ServiceProviderFinder", cnfe);
            }
        }
        return null;
    }
1320419
@NonNull
	public static ResolvedTypeWithMembers resolveMembers(@NonNull Type type, @NonNull Type... typeParameters)
	{
		ResolvedType rt = typeResolver.resolve(type, typeParameters);
		return memberResolver.resolve(rt, null, null);
	}
1275869
public void setXPathFunctionResolver(XPathFunctionResolver resolver) {
        if ( resolver == null ) {
            String fmsg = XSLMessages.createXPATHMessage( 
                    XPATHErrorResources.ER_ARG_CANNOT_BE_NULL,
                    new Object[] {"XPathFunctionResolver"} );
            throw new NullPointerException( fmsg );
        }
        this.functionResolver = resolver;
    }
1233526
protected String getRelayState(ProfileRequestContext<?, ?> context) {
    SAMLBindingContext samlBinding = this.samlBindingContextLookupStrategy.apply(context);
    return samlBinding != null ? samlBinding.getRelayState() : null;
  }
962607
public void setRolePolicyList(java.util.Collection<PolicyDetail> rolePolicyList) {
        if (rolePolicyList == null) {
            this.rolePolicyList = null;
            return;
        }

        this.rolePolicyList = new com.amazonaws.internal.SdkInternalList<PolicyDetail>(rolePolicyList);
    }
445236
public TransportResolver getResolver(JingleSession session) throws XMPPException, SmackException, InterruptedException {
        TransportResolver resolver = createResolver(session);
        if (resolver == null) {
            resolver = new BasicResolver();
        }
        resolver.initializeAndWait();

        return resolver;
    }
269901
public Map<Object, Object> getBootstrapProperties(ResolverWrapper resolver) {
		// return empty map
		if(resolver.bootstrap() == null) {
			return Collections.emptyMap();	
		}
		
		// get configuration wrapper
		ConfigurationWrapper wrapper = WrapperFactory.wrap(resolver.bootstrap());
		
		// bail early if nothing to do
		if(wrapper.sources() == null || wrapper.sources().length == 0) {
			return Collections.emptyMap();
		}
		
		// obtain instance of CommonsConfiguration provider
		CommonsConfigurationProducer instance = this.producer.get();
		
		// get commons configuration object from bootstrap
		org.apache.commons.configuration.Configuration config = instance.getConfiguration(wrapper);
		
		// wrap as map and return
		ConfigurationMap map = new ConfigurationMap(config);
		return map;
	}
400130
private static Plan resolvePlan( Plan plan, ProfiledPlan profiledPlan )
    {
        return plan == null ? profiledPlan : plan;
    }
933885
public static SPIProvider getInstance()
   {
      if (me == null)
      {
         final ClassLoader cl = ClassLoaderProvider.getDefaultProvider().getServerIntegrationClassLoader();
         me = SPIProviderResolver.getInstance(cl).getProvider();
      }
      return me;
   }
330455
protected @Nonnull <T> Provider<T> getBeanProvider(@Nullable BeanResolutionContext resolutionContext, @Nonnull Class<T> beanType, @Nullable Qualifier<T> qualifier) {
        ArgumentUtils.requireNonNull("beanType", beanType);
        @SuppressWarnings("unchecked") BeanRegistration<T> beanRegistration = singletonObjects.get(new BeanKey(beanType, qualifier));
        if (beanRegistration != null) {
            return new ResolvedProvider<>(beanRegistration.bean);
        }

        Optional<BeanDefinition<T>> concreteCandidate = findConcreteCandidate(beanType, qualifier, true, false);
        if (concreteCandidate.isPresent()) {
            return new UnresolvedProvider<>(beanType, qualifier, this);
        } else {
            throw new NoSuchBeanException(beanType);
        }
    }
259650
public static URIResolver createSAXURIResolver(Resolver resolver) {
    final SAXResolver saxResolver = new SAXResolver(resolver);
    return new URIResolver() {
      public Source resolve(String href, String base) throws TransformerException {
        try {
          return saxResolver.resolve(href, base);
        }
        catch (SAXException e) {
          throw toTransformerException(e);
        }
        catch (IOException e) {
          throw new TransformerException(e);
        }
      }
    };
  }