Gets the authentication method types combo box.

@return the authentication methods combo box
180221
protected JComboBox<AuthenticationMethodType> getAuthenticationMethodsComboBox() {
		if (authenticationMethodsComboBox == null) {
			Vector<AuthenticationMethodType> methods = new Vector<>(extension.getAuthenticationMethodTypes());
			authenticationMethodsComboBox = new JComboBox<>(methods);
			authenticationMethodsComboBox.setSelectedItem(null);

			// Prepare the listener for the change of selection
			authenticationMethodsComboBox.addItemListener(new ItemListener() {

				@Override
				public void itemStateChanged(ItemEvent e) {
					if (e.getStateChange() == ItemEvent.SELECTED && !e.getItem().equals(shownMethodType)) {
						log.debug("Selected new Authentication type: " + e.getItem());

						AuthenticationMethodType type = ((AuthenticationMethodType) e.getItem());
						if (shownMethodType == null || type.getAuthenticationCredentialsType() != shownMethodType
								.getAuthenticationCredentialsType()) {

							if (needsConfirm && !confirmAndResetUsersCredentials(type)) {
								log.debug("Cancelled change of authentication type.");

								authenticationMethodsComboBox.setSelectedItem(shownMethodType);
								return;
							}
						}
						resetLoggedInOutIndicators();

						// If no authentication method was previously selected or it's a different
						// class, create a new authentication method object
						if (selectedAuthenticationMethod == null
								|| !type.isTypeForMethod(selectedAuthenticationMethod)) {
							selectedAuthenticationMethod = type.createAuthenticationMethod(getContextIndex());
						}

						// Show the configuration panel
						changeMethodConfigPanel(type);
						if (type.hasOptionsPanel()) {
							shownConfigPanel.bindMethod(selectedAuthenticationMethod, getAuthenticationIndicatorsPanel());
						}
					}
				}
			});
		}
		return authenticationMethodsComboBox;
	}
828685
public Set<HttpMethod> getAllow() {
		String value = getFirst(ALLOW);
		if (!StringUtils.isEmpty(value)) {
			List<HttpMethod> allowedMethod = new ArrayList<HttpMethod>(5);
			String[] tokens = value.split(",\\s*");
			for (String token : tokens) {
				allowedMethod.add(HttpMethod.valueOf(token));
			}
			return EnumSet.copyOf(allowedMethod);
		}
		else {
			return EnumSet.noneOf(HttpMethod.class);
		}
	}
1071012
private String toApacheAuthenticationScheme(ProxyAuthenticationMethod authenticationMethod) {
        if (authenticationMethod == null) {
            throw new IllegalStateException("The configured proxy authentication methods must not be null.");
        }

        switch (authenticationMethod) {
            case NTLM: return AuthSchemes.NTLM;
            case BASIC: return AuthSchemes.BASIC;
            case DIGEST: return AuthSchemes.DIGEST;
            case SPNEGO: return AuthSchemes.SPNEGO;
            case KERBEROS: return AuthSchemes.KERBEROS;
            default: throw new IllegalStateException("Unknown authentication scheme: " + authenticationMethod);
        }
    }
1253714
private Set<ExecutableElement> getHookMethodsFromInterfaces() {
    return component
        .getInterfaces()
        .stream()
        .map(DeclaredType.class::cast)
        .map(DeclaredType::asElement)
        .map(TypeElement.class::cast)
        .flatMap(typeElement -> ElementFilter
            .methodsIn(typeElement.getEnclosedElements())
            .stream())
        .filter(method -> hasAnnotation(method, HookMethod.class))
        .peek(this::validateHookMethod)
        .collect(Collectors.toSet());
  }
92494
public GroovyMethodDoc[] methods() {
        Collections.sort(methods);
        return methods.toArray(new GroovyMethodDoc[methods.size()]);
    }
698891
@SuppressWarnings("unchecked")
	private JComboBox<HandleParametersOption> getComboHandleParameters() {
		if (handleParameters == null) {
			handleParameters = new JComboBox<>(new HandleParametersOption[] {
					HandleParametersOption.USE_ALL, HandleParametersOption.IGNORE_VALUE,
					HandleParametersOption.IGNORE_COMPLETELY });
			handleParameters.setRenderer(new HandleParametersOptionRenderer());
		}
		return handleParameters;
	}
1075282
private JCheckBox getHandleODataSpecificParameters() {
		if (handleODataSpecificParameters == null) {
			handleODataSpecificParameters = new JCheckBox();
			handleODataSpecificParameters.setText(Constant.messages.getString("spider.options.label.handlehodataparameters"));
		}
		return handleODataSpecificParameters;
	}
220628
public String getAuthType() {
        final AuthenticationSetting authSetting = getAuthenticationSetting();
        if (authSetting == null) {
            return "AzureCLI";
        }
        if (StringUtils.isNotEmpty(authSetting.getServerId())) {
            return "ServerId";
        }
        if (authSetting.getFile() != null) {
            return "AuthFile";
        }
        return "Unknown";
    }
533168
public static function getSupportedAuthMethods()
    {
        return array(
            ezcMailSmtpTransport::AUTH_DIGEST_MD5,
            ezcMailSmtpTransport::AUTH_CRAM_MD5,
            ezcMailSmtpTransport::AUTH_NTLM,
            ezcMailSmtpTransport::AUTH_LOGIN,
            ezcMailSmtpTransport::AUTH_PLAIN,
            );
    }
829882
public java.util.Map<String, IdentityVerificationAttributes> getVerificationAttributes() {
        if (verificationAttributes == null) {
            verificationAttributes = new com.amazonaws.internal.SdkInternalMap<String, IdentityVerificationAttributes>();
        }
        return verificationAttributes;
    }
1067279
public MethodDescriptor[] getMethodDescriptors() {
        BeanInfo info = getBeanInfo();
        if (info == null) {
            return null;
        }

        MethodDescriptor[] mds = info.getMethodDescriptors();      
        getTeaToolsUtils().sortMethodDescriptors(mds);
        return mds;
    }
210979
public String getAuthType()
    {
        if (WCCustomProperties.CHECK_REQUEST_OBJECT_IN_USE){
            checkRequestObjectInUse();
        }
        String authType = null;

        //if (com.ibm.ws.security.core.SecurityContext.isSecurityEnabled())
        if(((WebAppDispatcherContext)this.getDispatchContext()).isSecurityEnabledForApplication())
        {
            authType = (String) getPrivateAttribute("AUTH_TYPE");
        }
        else
        {
            authType = _request.getAuthType();
        }
        //321485
        if (TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) {  //306998.15
            logger.logp(Level.FINE, CLASS_NAME,"getAuthType", " authType --> " + authType);
        }
        // return one of the static vars defined in HttpServletRequest
        if (authType != null)
        {
            if (authType.equals("BASIC"))
                return HttpServletRequest.BASIC_AUTH;
            else if (authType.equals("CLIENT_CERT"))
                return HttpServletRequest.CLIENT_CERT_AUTH;
            else if (authType.equals("DIGEST"))
                return HttpServletRequest.DIGEST_AUTH;
            else if (authType.equals("FORM"))
                return HttpServletRequest.FORM_AUTH;
        }

        return authType;
    }
798860
private JComboBox<String> createStatusComboBox() {
        JComboBox<String> comboBox = new JComboBox<>();
        comboBox.addItem(Constant.messages.getString("ascan.policy.table.quality.all"));
        View view = View.getSingleton();
        comboBox.addItem(view.getStatusUI(AddOn.Status.release).toString());
        comboBox.addItem(view.getStatusUI(AddOn.Status.beta).toString());
        comboBox.addItem(view.getStatusUI(AddOn.Status.alpha).toString());
        return comboBox;
    }
253124
public List<AuthenticationMechanism<Resourceadapter<T>>> getAllAuthenticationMechanism()
   {
      List<AuthenticationMechanism<Resourceadapter<T>>> list = new ArrayList<AuthenticationMechanism<Resourceadapter<T>>>();
      List<Node> nodeList = childNode.get("authentication-mechanism");
      for(Node node: nodeList)
      {
         AuthenticationMechanism<Resourceadapter<T>>  type = new AuthenticationMechanismImpl<Resourceadapter<T>>(this, "authentication-mechanism", childNode, node);
         list.add(type);
      }
      return list;
   }
863055
@Override
    public String getAuthType() {
        String type = null;
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "getAuthType: " + type);
        }
        return type;
    }
1325435
public VoltType[] parameterTypes() {
        if (m_parameterTypes == null) {
            m_parameterTypes = new VoltType[getParameters().length];
            int ii = 0;
            for (ParameterValueExpression param : getParameters()) {
                m_parameterTypes[ii++] = param.getValueType();
            }
        }
        return m_parameterTypes;
    }
1262902
public ProxyAuthentication getProxyAuthentication() {
		// convert authentication to layerAuthentication so we only use one
		// TODO Remove when removing deprecated authentication field.
		if (layerAuthentication == null && authentication != null) {
			layerAuthentication = new LayerAuthentication();
			layerAuthentication.setAuthenticationMethod(LayerAuthenticationMethod.valueOf(authentication
					.getAuthenticationMethod().name()));
			layerAuthentication.setPassword(authentication.getPassword());
			layerAuthentication.setPasswordKey(authentication.getPasswordKey());
			layerAuthentication.setRealm(authentication.getRealm());
			layerAuthentication.setUser(authentication.getUser());
			layerAuthentication.setUserKey(authentication.getUserKey());
		}
		// TODO Remove when removing deprecated authentication field.
		return layerAuthentication;
	}