this loads the KeyManager class, if present
549778
private X509KeyManager loadCustomKeyManager(String kmClass) throws Exception {
        X509KeyManager km = null;

        try {
            ClassLoader cl = AccessController.doPrivileged(getCtxClassLoader);

            if (cl != null) {
                try {
                    km = (X509KeyManager) cl.loadClass(kmClass).newInstance();
                } catch (Exception e) {
                    // no ffdc needed
                }
            }

            if (km == null) {
                km = (X509KeyManager) Class.forName(kmClass).newInstance();
            }

            return km;
        } catch (Exception e) {
            FFDCFilter.processException(e, getClass().getName(), "loadCustomKeyManager", this);
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                Tr.debug(tc, "Exception loading custom KeyManager.", new Object[] { e });
            Tr.error(tc, "ssl.load.keymanager.error.CWPKI0021E", new Object[] { kmClass, e.getMessage() });
            throw e;
        }
    }
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);
		}
	}
1040537
def get_key(cls, k, default=None):
        
        k = cls.__name__ + "__" + k
        if k in session:
            return session[k]
        else:
            return default
925780
private Class<?> getKey(Class<?> key)
	{
		Class<?> newKey = lookupMap.get(key);
		if (newKey != null)
			return newKey;

		for (Class<?> c : internalMap.keySet())
		{
			if (c.isAssignableFrom(key))
			{
				lookupMap.put(key, c);
				return c;
			}
		}
		return null;
	}
46423
private static void checkAndTryToLoadEncryptionKey() {

		if (secretKeyHash == null) {

			// try to load from setting
			final String valueFromSetting = Settings.GlobalSecret.getValue();
			if (StringUtils.isNotBlank(valueFromSetting)) {

				logger.info("Secret key for encryption read from structr.conf.");
				CryptFunction.setEncryptionKey(valueFromSetting);
			}
		}
	}
991065
private void ckeckKey(KeyType keyType) {
		switch (keyType) {
		case PublicKey:
			if (null == this.publicKey) {
				throw new NullPointerException("No public key provided");
			}
			break;
		case PrivateKey:
			if (null == this.privateKey) {
				throw new NullPointerException("No private key provided");
			}
			break;
		}
	}
589352
private Class<?> loadClass(final ClassLoader lastLoader, final String className) {
        // XXX: this is overly complicated
        Class<?> clazz;
        if (lastLoader != null) {
            try {
                clazz = lastLoader.loadClass(className);
                if (clazz != null) {
                    return clazz;
                }
            } catch (final Throwable ignore) {
                // Ignore exception.
            }
        }
        try {
            clazz = LoaderUtil.loadClass(className);
        } catch (final ClassNotFoundException | NoClassDefFoundError e) {
            return loadClass(className);
        } catch (final SecurityException e) {
            return null;
        }
        return clazz;
    }
428746
synchronized public boolean load() {
		if (null == this.settingLoader) {
			settingLoader = new SettingLoader(this.groupedMap, this.charset, this.isUseVariable);
		}
		return settingLoader.load(new UrlResource(this.settingUrl));
	}
1156520
def withconfig(self, keysuffix):
        
        def decorator(cls):
            return self.loadconfig(keysuffix, cls)
        return decorator
1052096
private function conditional_load(string $key, string $class)
    {
        if (Config::get($key) === true) {
            $this->class_list[] = $class;
        }
    }
1121797
def _process_key(self, key):
        """"""
        # Handle the driver case first.
        if self.mode != ray.WORKER_MODE:
            if key.startswith(b"FunctionsToRun"):
                with profiling.profile("fetch_and_run_function"):
                    self.fetch_and_execute_function_to_run(key)
            # Return because FunctionsToRun are the only things that
            # the driver should import.
            return

        if key.startswith(b"RemoteFunction"):
            with profiling.profile("register_remote_function"):
                (self.worker.function_actor_manager.
                 fetch_and_register_remote_function(key))
        elif key.startswith(b"FunctionsToRun"):
            with profiling.profile("fetch_and_run_function"):
                self.fetch_and_execute_function_to_run(key)
        elif key.startswith(b"ActorClass"):
            # Keep track of the fact that this actor class has been
            # exported so that we know it is safe to turn this worker
            # into an actor of that class.
            self.worker.function_actor_manager.imported_actor_classes.add(key)
        # TODO(rkn): We may need to bring back the case of
        # fetching actor classes here.
        else:
            raise Exception("This code should be unreachable.")
633455
public Map<String, List<Object>> batchLoad(Map<Class<?>, List<KeyPair>> itemsToGet) {
        return batchLoad(itemsToGet, this.config);
    }
363988
protected final void loadKeys(String key, String[] value) {
        String[] parsed = parseKey(key);

        if (parsed == null) {
            return;
        }

        if (!queryMap.containsKey(parsed[0])) {
            queryMap.put(parsed[0], new QueryParamsMap());
        }
        if (!parsed[1].isEmpty()) {
            queryMap.get(parsed[0]).loadKeys(parsed[1], value);
        } else {
            queryMap.get(parsed[0]).values = value.clone();
        }
    }
725694
def load_key_file(self):
        """"""
        self.client_key = None
        if self.key_file_path:
            key_file_path = self.key_file_path
        else:
            key_file_path = self._get_key_file_path()
        key_dict = {}

        logger.debug('load keyfile from %s', key_file_path);

        if os.path.isfile(key_file_path):
            with open(key_file_path, 'r') as f:
                raw_data = f.read()
                if raw_data:
                    key_dict = json.loads(raw_data)

        logger.debug('getting client_key for %s from %s', self.ip, key_file_path);
        if self.ip in key_dict:
            self.client_key = key_dict[self.ip]
871363
def get_key(cls, key):
        ""
        return cls.get().get(key, cls.DEFAULT_CONFIG.get(key,None))
1227736
function() {
        // load a level
        me.levelDirector.loadLevel("village");
        // subscribe to key down event
        this.handle = me.event.subscribe(me.event.KEYDOWN, this.keyPressed.bind(this));
    }
455232
public static void loadDefaultEncryptionModule() {
		// Be sure that the cryptographical algorithms are loaded
		final Provider[] providers = Security.getProviders();
		boolean found = false;
		for (final Provider provider : providers) {
			if (provider instanceof SunJCE) {
				found = true;
				break;
			}
		}
		if (!found) {
			Security.addProvider(new SunJCE());
		}
	}