Returns optional default {@link DesiredCapabilities}. They are
constructed from system properties starting with
{@link BasicSebConfiguration#CAPABILITIES_PREFIX}. Override this for
different value.

@return The desired capabilities.
505343
protected DesiredCapabilities getDefaultCapabilities() {
		DesiredCapabilities caps = new DesiredCapabilities();
		getMergedProperties(
				entry -> entry.getKey() != null && entry.getKey().toString().startsWith(CAPABILITIES_PREFIX))
						.forEach((key, value) -> {
							caps.setCapability(key.toString().substring(CAPABILITIES_PREFIX.length()), value);
						});
		return caps;
	}
1135108
public static Optional<CasConfigurationProperties> getCasConfigurationProperties() {
        if (CONTEXT != null) {
            return Optional.of(CONTEXT.getBean(CasConfigurationProperties.class));
        }
        return Optional.empty();
    }
753844
public static Options defaultOptions() {
        return new Options(
                HELP,
                CONFIG_HELP,
                YAML_HELP,
                VERSION,
                PROPERTY,
                PROPERTIES_URL,
                SERVER_CONFIG,
                CONFIG,
                PROFILES,
                BIND
        );
    }
35300
public static ClassNameResolver buildDefault() {
        String enable = System.getProperty(Constants.SERIALIZE_BLACKLIST_ENABLE,
            Constants.DEFAULT_SERIALIZE_BLACKLIST_ENABLE);
        if (Boolean.TRUE.toString().equalsIgnoreCase(enable)) {
            ClassNameResolver resolver = new ClassNameResolver();
            resolver.addFilter(new InternalNameBlackListFilter());
            return resolver;
        }
        return null;
    }
205594
protected ObjectiveProperties prepareObjectiveProperties() {
        final ObjectiveProperties makingProp = newObjectiveProperties(appResource, preparePropertyFilter());
        makingProp.checkImplicitOverride();
        makingProp.encodeAsUTF8(); // fixedly, so not need to encode japanese 
        if (!extendsResourceList.isEmpty()) {
            makingProp.extendsProperties(extendsResourceList.toArray(new String[extendsResourceList.size()]));
        }
        return makingProp;
    }
206452
public EndpointInfoBuilder defaultMimeType(MediaType defaultMimeType) {
        requireNonNull(defaultMimeType, "defaultMimeType");
        this.defaultMimeType = defaultMimeType;

        if (availableMimeTypes == null) {
            availableMimeTypes = ImmutableSet.of(defaultMimeType);
        } else if (!availableMimeTypes.contains(defaultMimeType)) {
            availableMimeTypes = addDefaultMimeType(defaultMimeType, availableMimeTypes);
        }
        return this;
    }
1103108
public static CapabilityRequirement hasAll(Capability... capabilities) {
    return new CapabilityRequirement(c -> {
      for (Capability capability : capabilities) {
        if (!c.hasCapability(capability))
          return false;
      }
      return true;
    });
  }
291007
public Set<String> getSupportedTypes(){
		Set<String> typeset = new HashSet<String>();
		Set<String> set = factory.DefaultLabelAlphabet().toSet();
		Iterator<String> itt = set.iterator();
		while(itt.hasNext()){
			String type = itt.next();
			if(type.length() ==1 )
				continue;
			typeset.add(type.substring(1));
		}
		return typeset;
	}
223922
public com.google.api.SystemParameters getSystemParameters() {
    return systemParameters_ == null ? com.google.api.SystemParameters.getDefaultInstance() : systemParameters_;
  }
804555
public java.util.List<CapacityReservation> getCapacityReservations() {
        if (capacityReservations == null) {
            capacityReservations = new com.amazonaws.internal.SdkInternalList<CapacityReservation>();
        }
        return capacityReservations;
    }
717672
public static Configuration defaultConfiguration() {
        Defaults defaults = getEffectiveDefaults();
        return Configuration.builder().jsonProvider(defaults.jsonProvider()).options(defaults.options()).build();
    }
921613
public Configuration create() {
        Configuration configuration;
        try {
            InputStream stream = null;
            try {
                // Search the user configuration
                stream = Utils.openResourceStream(DEFAULT_USER_CONFIGURATION_FILE);

                // If user configuration not found then use default
                if (stream == null) {
                    stream = Utils.openResourceStream(DEFAULT_CONFIGURATION_FILE);
                }

                if (stream != null) {
                    configuration = create(stream);
                } else {
                    throw new TextProcessorFactoryException("Can't find or open default configuration resource.");
                }
            } finally {
                if (stream != null) {
                    stream.close();
                }
            }

            Properties properties = new Properties();

            // Load properties from .property file
            InputStream propertiesStream = null;
            try {
                propertiesStream = Utils.openResourceStream(DEFAULT_PROPERTIES_FILE);
                if (propertiesStream != null) {
                    properties.load(propertiesStream);
                }
            } finally {
                if (propertiesStream != null) {
                    propertiesStream.close();
                }
            }

            // Load properties from xml file
            InputStream xmlPropertiesStream = null;
            try {
                xmlPropertiesStream = Utils.openResourceStream(DEFAULT_PROPERTIES_XML_FILE);
                if (xmlPropertiesStream != null) {
                    properties.loadFromXML(xmlPropertiesStream);
                }
            } finally {
                if (xmlPropertiesStream != null) {
                    xmlPropertiesStream.close();
                }
            }

            if (!properties.isEmpty()) {
                Map<String, CharSequence> params = new HashMap<String, CharSequence>();
                params.putAll(configuration.getParams());
                for (Map.Entry<Object, Object> entry : properties.entrySet()) {
                    Object key = entry.getKey();
                    if (key != null) {
                        params.put(key.toString(), entry.getValue().toString());
                    }
                }
                configuration.setParams(params);
            }
        } catch (IOException e) {
            throw new TextProcessorFactoryException(e);
        }

        return configuration;
    }
340437
private static Capabilities dropCapabilities(Capabilities capabilities) {
    if (capabilities == null) {
      return new ImmutableCapabilities();
    }

    MutableCapabilities caps;

    if (isLegacy(capabilities)) {
      final Set<String> toRemove = Sets.newHashSet(BINARY, PROFILE);
      caps = new MutableCapabilities(
          Maps.filterKeys(capabilities.asMap(), key -> !toRemove.contains(key)));
    } else {
      caps = new MutableCapabilities(capabilities);
    }

    // Ensure that the proxy is in a state fit to be sent to the extension
    Proxy proxy = Proxy.extractFrom(capabilities);
    if (proxy != null) {
      caps.setCapability(PROXY, proxy);
    }

    return caps;
  }
106946
public final String getPrefix() {
		if ((prefix == null || prefix.isEmpty()) && (configuration != null)) {
			prefix = configuration.getPrefix();
		}
		return prefix;
	}
591331
public static List<CmsResourceTableProperty> defaultProperties() {

        return Arrays.asList(
            PROPERTY_PROJECT,
            PROPERTY_DATE_CREATED,
            PROPERTY_DATE_EXPIRED,
            PROPERTY_DATE_MODIFIED,
            PROPERTY_DATE_RELEASED,
            PROPERTY_IS_FOLDER,
            PROPERTY_NAVIGATION_TEXT,
            PROPERTY_COPYRIGHT,
            PROPERTY_CACHE,
            PROPERTY_PERMISSIONS,
            PROPERTY_RESOURCE_NAME,
            PROPERTY_RESOURCE_TYPE,
            PROPERTY_SIZE,
            PROPERTY_STATE,
            PROPERTY_STATE_NAME,
            PROPERTY_TITLE,
            PROPERTY_TYPE_ICON,
            PROPERTY_USER_CREATED,
            PROPERTY_USER_LOCKED,
            PROPERTY_USER_MODIFIED);
    }
117338
protected synchronized PrefixedProperties createProperties() {
		if (myProperties == null) {
			PrefixedProperties resultProperties = null;
			String environment = defaultPrefix;
			if (environmentFactory != null) {
				environment = environmentFactory.getEnvironment();
			} else if (defaultPrefixSystemPropertyKey != null) {
				environment = System.getProperty(defaultPrefixSystemPropertyKey);
				if (environment == null) {
					if (logger.isWarnEnabled()) {
						logger.warn(String.format("Didn't found system property key to set default prefix: %1s",
								defaultPrefixSystemPropertyKey));
					}
				}
			}
			if (prefixConfigList != null) {
				resultProperties = PrefixedProperties.createCascadingPrefixProperties(prefixConfigList);
			} else {
				if (environment != null) {
					resultProperties = PrefixedProperties.createCascadingPrefixProperties(environment);
				} else {
					resultProperties = new PrefixedProperties();
				}
			}
			resultProperties.setDefaultPrefix(environment);
			if (logger.isInfoEnabled()) {
				logger.info(String.format("Setting default prefix to: %1s", environment));
			}
			resultProperties.setMixDefaultAndLocalPrefixSettings(mixDefaultAndLocalPrefixConfigurations);
			myProperties = resultProperties;
		}
		return myProperties;
	}
858467
public static Initialization makeDefault() {
        Initialization initialization = new Initialization();
        initialization.entryPoint = EntryPoint.Default.REBASE.name();
        return initialization;
    }