sets the secure Level

@param secureLevel [SECURE_CFSSL_BASIC, SECURE_CFSSL_CLIENT_AUTH, SECURE_NONE]
@throws ClassNotFoundException
@throws ClassException
439005
public void setSecureLevel(short secureLevel) throws ClassException {
	// Security
	if (secureLevel == SECURE_CFSSL_BASIC) {
	    env.put("java.naming.security.protocol", "ssl");
	    env.put("java.naming.ldap.factory.socket", "javax.net.ssl.SSLSocketFactory");
	    ClassUtil.loadClass("com.sun.net.ssl.internal.ssl.Provider");

	    Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());

	}
	else if (secureLevel == SECURE_CFSSL_CLIENT_AUTH) {
	    env.put("java.naming.security.protocol", "ssl");
	    env.put("java.naming.security.authentication", "EXTERNAL");
	}
	else {
	    env.put("java.naming.security.authentication", "simple");
	    env.remove("java.naming.security.protocol");
	    env.remove("java.naming.ldap.factory.socket");
	}
    }
976768
public com.google.appengine.v1.SecurityLevel getSecurityLevel() {
    com.google.appengine.v1.SecurityLevel result = com.google.appengine.v1.SecurityLevel.valueOf(securityLevel_);
    return result == null ? com.google.appengine.v1.SecurityLevel.UNRECOGNIZED : result;
  }
223076
public void setLevels(Map<Integer, Long> levels) {
        SystemAssert.requireArgument(levels != null, "Levels cannot be null");
        this.levels.clear();
        this.levels.putAll(levels);
    }
1371753
@Deprecated
    public void setMinLevel(String minLevel) {
        this.minLevel = minLevel != null ? Level.toLevel(minLevel) : null;
    }
1139204
@Reference(name = KEY_SECURITY_SERVICE, policy = ReferencePolicy.DYNAMIC)
    protected void setSecurityService(SecurityService securitysvc) {
        securityService = securitysvc;
    }
764349
public void setSecureSiteUrl(String secureSiteUrl) {
        this.secureSiteUrl = StringUtils.isBlank(secureSiteUrl) ? new ServerSiteUrlConfig() : new ServerSiteUrlConfig(secureSiteUrl);
    }
1360730
public void setInputSecurityGroups(java.util.Collection<String> inputSecurityGroups) {
        if (inputSecurityGroups == null) {
            this.inputSecurityGroups = null;
            return;
        }

        this.inputSecurityGroups = new java.util.ArrayList<String>(inputSecurityGroups);
    }
1145778
@Override
    public boolean isSecure() {
        boolean secure = (null != this.connection.getSSLContext());
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "isSecure: " + secure);
        }
        return secure;
    }
253616
private static void init(ClassLoader classLoader, SecurityManager securityManager, Set<String> securedClasses) {
		if (classLoader == null)
			throw new IllegalArgumentException("A class loader must be provided");
		
		if (securityManager == null)
			throw new IllegalArgumentException("A security manager must be provided");
		
		if (securedClasses == null)
			throw new IllegalArgumentException("Secured classes cannot be null");
		
		Security.securityManager = securityManager;

		ClassPool cp = ClassPool.getDefault();

		for (String securedClass : securedClasses) {
			secure(classLoader, cp, securedClass);
		}
	}
257540
public void setMemberServices(MemberServices memberServices) {
        this.memberServices = memberServices;
        if (memberServices instanceof MemberServicesImpl) {
           this.cryptoPrimitives = ((MemberServicesImpl) memberServices).getCrypto();
        }
    }
6135
public void setThreshold(final Level level) {
        Level oldValue = this.thresholdLevel;
        thresholdLevel = level;
        firePropertyChange("threshold", oldValue, this.thresholdLevel);
    }
1140149
private void setCL(final ClassLoader cl) {
        PrivilegedAction<Object> action = new PrivilegedAction<Object>() {
            @Override
            @FFDCIgnore(SecurityException.class)
            public Object run() {
                final Thread t = Thread.currentThread();
                try {
                    t.setContextClassLoader(cl);
                } catch (SecurityException e) {
                    // If this work happens to run on an java.util.concurrent.ForkJoinWorkerThread$InnocuousForkJoinWorkerThread,
                    // setting the ClassLoader may be rejected. If this happens, give a decent error message.
                    if (t instanceof ForkJoinWorkerThread && "InnocuousForkJoinWorkerThreadGroup".equals(t.getThreadGroup().getName())) {
                        throw new SecurityException(Tr.formatMessage(tc, "cannot.apply.classloader.context", t.getName()), e);
                    } else {
                        throw e;
                    }
                }
                return null;
            }
        };
        AccessController.doPrivileged(action);
    }
820709
public synchronized String[] adjustSupportedCiphersToSecurityLevel(String[] supportedCiphers, String securityLevel) {
        return (Constants.adjustSupportedCiphersToSecurityLevel(supportedCiphers, securityLevel));
    }
599765
public void setSecurityManager(CmsSecurityManager securityManager) {

        if (m_frozen) {
            throw new CmsRuntimeException(Messages.get().container(Messages.ERR_CONFIG_SUBSCRIPTIONMANAGER_FROZEN_0));
        }
        m_securityManager = securityManager;
    }
689664
public void setSecurityGroups(java.util.Collection<String> securityGroups) {
        if (securityGroups == null) {
            this.securityGroups = null;
            return;
        }

        this.securityGroups = new java.util.ArrayList<String>(securityGroups);
    }
655975
func (c *Config) SecurityLevel() int {
	val, ok := c.backend.Lookup("client.BCCSP.security.level")
	if !ok {
		return defLevel
	}
	return cast.ToInt(val)
}
752961
public static void setDefaultLevel(java.util.logging.Level level) {
    Logger.getLogger(TOPLEVEL_PACKAGE).setLevel(level);
  }