private WizardStepPanel setupWizardFlow() { // get the consent mode variable value EnumSet<ConsentMode> supportedConsentMode = consentService.getSupportedConsentModes(); List<Locale> supportedConsentLocale = consentService.getSupportedConsentLocales(); WizardStepPanel startStep; if (supportedConsentMode.containsAll(EnumSet.allOf(ConsentMode.class)) || supportedConsentMode.contains(ConsentMode.MANUAL) && supportedConsentLocale.size() > 1) { startStep = consentModeSelectionStep; startStep.setPreviousStep(startStep); electronicConsentStep.setPreviousStep(startStep); } else { consentConfirmationStep.setPreviousStep(null); startStep = consentConfirmationStep; } return startStep; }
/** * Grants a new permission for a given subject and resource. * * @param subjectid the subject to give permissions to * @param resourceName the resource name/type * @param permission the set or HTTP methods allowed * @return true if successful */ public boolean grantResourcePermission( String subjectid, String resourceName, EnumSet<AllowedMethods> permission) { // clean up resource name resourceName = Utils.noSpaces(resourceName, "-"); if (!StringUtils.isBlank(subjectid) && !StringUtils.isBlank(resourceName) && permission != null && !permission.isEmpty()) { if (!getResourcePermissions().containsKey(subjectid)) { Map<String, List<String>> perm = new HashMap<String, List<String>>(); perm.put(resourceName, new ArrayList<String>(permission.size())); for (AllowedMethods allowedMethod : permission) { perm.get(resourceName).add(allowedMethod.toString()); } getResourcePermissions().put(subjectid, perm); } else { if (permission.containsAll(AllowedMethods.ALL_VALUES) || permission.contains(AllowedMethods.READ_WRITE) || (permission.contains(AllowedMethods.READ_ONLY) && permission.contains(AllowedMethods.WRITE_ONLY)) || (permission.contains(AllowedMethods.GET) && permission.contains(AllowedMethods.WRITE_ONLY))) { permission = AllowedMethods.READ_AND_WRITE; } else { if (permission.contains(AllowedMethods.WRITE_ONLY)) { permission = AllowedMethods.WRITE; } else if (permission.contains(AllowedMethods.READ_ONLY)) { permission = AllowedMethods.READ; } } List<String> perm = new ArrayList<String>(permission.size()); for (AllowedMethods allowedMethod : permission) { perm.add(allowedMethod.toString()); } getResourcePermissions().get(subjectid).put(resourceName, perm); } return true; } return false; }
/** * Select the technique to use for rendering this material. * * <p>If <code>name</code> is "Default", then one of the {@link MaterialDef#getDefaultTechniques() * default techniques} on the material will be selected. Otherwise, the named technique will be * found in the material definition. * * <p>Any candidate technique for selection (either default or named) must be verified to be * compatible with the system, for that, the <code>renderManager</code> is queried for * capabilities. * * @param name The name of the technique to select, pass "Default" to select one of the default * techniques. * @param renderManager The {@link RenderManager render manager} to query for capabilities. * @throws IllegalArgumentException If "Default" is passed and no default techniques are available * on the material definition, or if a name is passed but there's no technique by that name. * @throws UnsupportedOperationException If no candidate technique supports the system * capabilities. */ public void selectTechnique(String name, RenderManager renderManager) { // check if already created Technique tech = techniques.get(name); // When choosing technique, we choose one that // supports all the caps. EnumSet<Caps> rendererCaps = renderManager.getRenderer().getCaps(); if (tech == null) { if (name.equals("Default")) { List<TechniqueDef> techDefs = def.getDefaultTechniques(); if (techDefs == null || techDefs.isEmpty()) { throw new IllegalArgumentException( "No default techniques are available on material '" + def.getName() + "'"); } TechniqueDef lastTech = null; for (TechniqueDef techDef : techDefs) { if (rendererCaps.containsAll(techDef.getRequiredCaps())) { // use the first one that supports all the caps tech = new Technique(this, techDef); techniques.put(name, tech); break; } lastTech = techDef; } if (tech == null) { throw new UnsupportedOperationException( "No default technique on material '" + def.getName() + "'\n" + " is supported by the video hardware. The caps " + lastTech.getRequiredCaps() + " are required."); } } else { // create "special" technique instance TechniqueDef techDef = def.getTechniqueDef(name); if (techDef == null) { throw new IllegalArgumentException( "For material " + def.getName() + ", technique not found: " + name); } if (!rendererCaps.containsAll(techDef.getRequiredCaps())) { throw new UnsupportedOperationException( "The explicitly chosen technique '" + name + "' on material '" + def.getName() + "'\n" + "requires caps " + techDef.getRequiredCaps() + " which are not " + "supported by the video renderer"); } tech = new Technique(this, techDef); techniques.put(name, tech); } } else if (technique == tech) { // attempting to switch to an already // active technique. return; } technique = tech; tech.makeCurrent(def.getAssetManager(), true, rendererCaps); // shader was changed sortingId = -1; }
/** * Creates a list of detectors applicable to the given cope, and with the given configuration. * * @param client the client to report errors to * @param configuration the configuration to look up which issues are enabled etc from * @param scope the scope for the analysis, to filter out detectors that require wider analysis * than is currently being performed * @param scopeToDetectors an optional map which (if not null) will be filled by this method to * contain mappings from each scope to the applicable detectors for that scope * @return a list of new detector instances */ @NonNull final List<? extends Detector> createDetectors( @NonNull LintClient client, @NonNull Configuration configuration, @NonNull EnumSet<Scope> scope, @Nullable Map<Scope, List<Detector>> scopeToDetectors) { List<Issue> issues = getIssues(); Set<Class<? extends Detector>> detectorClasses = new HashSet<Class<? extends Detector>>(); Map<Class<? extends Detector>, EnumSet<Scope>> detectorToScope = new HashMap<Class<? extends Detector>, EnumSet<Scope>>(); for (Issue issue : issues) { Class<? extends Detector> detectorClass = issue.getDetectorClass(); EnumSet<Scope> issueScope = issue.getScope(); if (!detectorClasses.contains(detectorClass)) { // Determine if the issue is enabled if (!configuration.isEnabled(issue)) { continue; } // Determine if the scope matches if (!issue.isAdequate(scope)) { continue; } detectorClass = client.replaceDetector(detectorClass); assert detectorClass != null : issue.getId(); detectorClasses.add(detectorClass); } if (scopeToDetectors != null) { EnumSet<Scope> s = detectorToScope.get(detectorClass); if (s == null) { detectorToScope.put(detectorClass, issueScope); } else if (!s.containsAll(issueScope)) { EnumSet<Scope> union = EnumSet.copyOf(s); union.addAll(issueScope); detectorToScope.put(detectorClass, union); } } } List<Detector> detectors = new ArrayList<Detector>(detectorClasses.size()); for (Class<? extends Detector> clz : detectorClasses) { try { Detector detector = clz.newInstance(); detectors.add(detector); if (scopeToDetectors != null) { EnumSet<Scope> union = detectorToScope.get(clz); for (Scope s : union) { List<Detector> list = scopeToDetectors.get(s); if (list == null) { list = new ArrayList<Detector>(); scopeToDetectors.put(s, list); } list.add(detector); } } } catch (Throwable t) { client.log(t, "Can't initialize detector %1$s", clz.getName()); // $NON-NLS-1$ } } return detectors; }