<p>
The capabilities allowed in the stack.
</p>

@return The capabilities allowed in the stack.
@see Capability
499712
public java.util.List<String> getCapabilities() {
        if (capabilities == null) {
            capabilities = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return capabilities;
    }
1131261
@Override
    public synchronized boolean hasCapability(final String capability) throws MessagingException {
        return capability != null
                && (capability.toLowerCase().startsWith("IMAP4") || capability.toLowerCase().startsWith("IDLE") || capability.toLowerCase()
                        .startsWith("ID"));
    }
375001
@SuppressWarnings("unchecked")
    public <C extends Capability> C getCapability(Class<C> capabilityType) {
        if (capabilityType.isInstance(this)) {
            return (C) this;
        }
        return null;
    }
1103108
public static CapabilityRequirement hasAll(Capability... capabilities) {
    return new CapabilityRequirement(c -> {
      for (Capability capability : capabilities) {
        if (!c.hasCapability(capability))
          return false;
      }
      return true;
    });
  }
537917
public java.util.List<AvailableProcessorFeature> getValidProcessorFeatures() {
        if (validProcessorFeatures == null) {
            validProcessorFeatures = new com.amazonaws.internal.SdkInternalList<AvailableProcessorFeature>();
        }
        return validProcessorFeatures;
    }
1251862
public java.util.List<NetworkInterfacePermission> getNetworkInterfacePermissions() {
        if (networkInterfacePermissions == null) {
            networkInterfacePermissions = new com.amazonaws.internal.SdkInternalList<NetworkInterfacePermission>();
        }
        return networkInterfacePermissions;
    }
341232
public Capabilities toCapabilities() {
    DesiredCapabilities capabilities = DesiredCapabilities.opera();

    for (CapabilityInstance option : options.values()) {
      if (option.getValue() == null) {
        continue;
      }

      capabilities.setCapability(option.getCapability(), option.getValue());
    }

    return capabilities.merge(surplusCapabilities);
  }
351815
private short getClientCapabilities()
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getClientCapabilities");
      
      short capabilities = CommsConstants.CAPABILITIES_DEFAULT;
      
      // Allow the use of a runtime property to alter the capability that we require a non-java
      // bootstrap to locate an ME
      boolean nonJavaBootstrap =
         CommsUtils.getRuntimeBooleanProperty(CommsConstants.CAPABILITIY_REQUIRES_NONJAVA_BOOTSTRAP_KEY,
                                              CommsConstants.CAPABILITIY_REQUIRES_NONJAVA_BOOTSTRAP_DEF);

      if (nonJavaBootstrap)
      {
         if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Requesting non-java bootstrap");
         // This bit is off by default, so turn it on
         capabilities |= CommsConstants.CAPABILITIY_REQUIRES_NONJAVA_BOOTSTRAP;
      }
      
      // Allow the use of a runtime property to alter the capability that we require JMF messages
      boolean jmfMessagesOnly = 
         CommsUtils.getRuntimeBooleanProperty(CommsConstants.CAPABILITIY_REQUIRES_JMF_ENCODING_KEY,
                                              CommsConstants.CAPABILITIY_REQUIRES_JMF_ENCODING_DEF);
      
      if (jmfMessagesOnly)
      {
         if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Requesting JMF Only");
         // This bit is off by default, so turn it on
         capabilities |= CommsConstants.CAPABILITIY_REQUIRES_JMF_ENCODING;
      }

      // Allow the use of a runtime property to alter the capability that we require JMS messages
      boolean jmsMessagesOnly = 
         CommsUtils.getRuntimeBooleanProperty(CommsConstants.CAPABILITIY_REQUIRES_JMS_MESSAGES_KEY,
                                              CommsConstants.CAPABILITIY_REQUIRES_JMS_MESSAGES_DEF);
      
      if (jmsMessagesOnly)
      {
         if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Requesting JMS Only");
         // This bit is off by default, so turn it on
         capabilities |= CommsConstants.CAPABILITIY_REQUIRES_JMS_MESSAGES;
      }
      
      // Allow the use of a runtime property to turn off optimized transactions.
      boolean disableOptimizedTx =
         CommsUtils.getRuntimeBooleanProperty(CommsConstants.DISABLE_OPTIMIZED_TX_KEY,
                                              CommsConstants.DISABLE_OPTIMIZED_TX);
      
      if (disableOptimizedTx)
      {
         if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Disabling use of optimized transactions");
         // This bit is set on by default, so we must turn it off
         capabilities &= (0xFFFF ^ CommsConstants.CAPABILITIY_REQUIRES_OPTIMIZED_TX);
      }
      
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getClientCapabilities", capabilities);
      return capabilities;
   }
45968
def capabilities(self):
		

		caps = []
		for cap in DeviceCapability:
			if self._libinput.libinput_device_has_capability(self._handle, cap):
				caps.append(cap)
		return tuple(caps)
997465
public java.util.List<AllowedPrincipal> getAllowedPrincipals() {
        if (allowedPrincipals == null) {
            allowedPrincipals = new com.amazonaws.internal.SdkInternalList<AllowedPrincipal>();
        }
        return allowedPrincipals;
    }
1047877
public function capabilitiesAction()
    {
        $routes = $this->router->getRouteCollection();
        $exposed = [];

        foreach ($routes as $name => $route) {
            if (!$route->hasDefault(RouteKeys::DEFINITION)) {
                continue;
            }

            if (!in_array('OPTIONS', $route->getMethods(), true)) {
                continue;
            }

            $definition = $route->getDefault(RouteKeys::DEFINITION);
            list($collection, $resource) = explode('::', $definition);
            $definition = $this
                ->registry
                ->getCollection($collection)
                ->getResource($resource);

            if ($definition->hasOption('private')) {
                continue;
            }

            $exposed[$name] = $route;
        }

        return $exposed;
    }
1163841
public java.util.List<String> getSupportedTierList() {
        if (supportedTierList == null) {
            supportedTierList = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return supportedTierList;
    }
673293
def get_sieve_capabilities(self):
        
        if isinstance(self.__capabilities["SIEVE"], six.string_types):
            self.__capabilities["SIEVE"] = self.__capabilities["SIEVE"].split()
        return self.__capabilities["SIEVE"]
603322
public java.util.List<String> getAvailablePortSpeeds() {
        if (availablePortSpeeds == null) {
            availablePortSpeeds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return availablePortSpeeds;
    }
93392
public static DesiredCapabilities retrieveCustomCapabilities(String[] capabilitiesArray) {
        logger.entering((Object[]) capabilitiesArray);

        DesiredCapabilities caps = new DesiredCapabilities();
        if (capabilitiesArray.length != 0) {
            Map<String, Object> capabilityMap = parseIntoCapabilities(capabilitiesArray);
            // We found some capabilities. Lets merge them.
            caps = new DesiredCapabilities(capabilityMap);
        }

        logger.exiting(caps);
        return caps;
    }
743561
@Override
    public boolean hasCapability(String capabilityName, CapabilityScope scope) {
        readLock.lock();
        try {
            return findSatisfactoryCapability(capabilityName, scope, !forServer) != null;
        } finally {
            readLock.unlock();
        }
    }
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;
  }