Make check - service provider is loaded or not?

@param string $class_name

@return bool
518330
protected function serviceProviderIsRegistered($class_name)
    {
        if (\method_exists($this->app, 'getLoadedProviders')) {
            $loaded = \array_keys($this->app->getLoadedProviders());

            return \in_array($class_name, $loaded, true);
        }

        return false;
    }
930997
public function check(): bool
    {
        $auth = $this->parseAuthenticationConfiguration(\config('auth'));

        try {
            $this->description = Str::replace($this->description, ['model' => $auth['provider']['model']]);

            return $this->validateUserProvider($auth) && $this->validateUserInstance($auth);
        } catch (ReflectionException $e) {
            // Catch ReflectionException and return false.
        } finally {
            // Catch any exception.
        }

        return false;
    }
364006
public static function getUrlService($service_name) {
    $url_khipu = 'https://khipu.com/api/' . self::VERSION_KHIPU_SERVICE . '/';

    $services_name = self::getAllServicesName();

    if (array_key_exists($service_name, $services_name)) { 
       $str = $service_name;
       $str[0] = strtolower($str[0]);
       return $url_khipu . (string)$str;
    }
    return FALSE;
  }
648145
public static function loader($className) {		
		if(!isset(self::$loader_cache)) {
			self::buildLoaderCache();
		}
		
		if(isset(self::$loader_cache[$className])) {
			require_once(self::$loader_cache[$className]);
			return true;
		}
		else {
			return false;
		}
	}
811311
protected function _fetch_object($class_name = 'stdClass')
	{
		// No native support for fetching rows as objects
		if (($row = $this->result_id->fetchArray(SQLITE3_ASSOC)) === FALSE)
		{
			return FALSE;
		}
		elseif ($class_name === 'stdClass')
		{
			return (object) $row;
		}

		$class_name = new $class_name();
		foreach (array_keys($row) as $key)
		{
			$class_name->$key = $row[$key];
		}

		return $class_name;
	}
548407
public function getJavaClass(string $class_name): Interfaces\JavaClass
    {
        try {
            $class = $this->pjbProxyClient->getJavaClass($class_name);
        } catch (Pjb62BrokenConnectionException | Exception\InvalidUsageException $e) {
            PjbProxyClient::unregisterInstance();
            throw new BrokenConnectionException($e->getMessage(), $e->getCode(), $e);
        }

        return $class;
    }
947406
public function isValidConfigurator($className)
    {
        //====================================================================//
        // Verify Class Exists
        if (false == class_exists($className)) {
            return Splash::log()->err('Configurator Class Not Found: '.$className);
        }

        //====================================================================//
        // Verify Configurator Class Extends ConfiguratorInterface
        try {
            $class = new $className();
            if (!($class instanceof ConfiguratorInterface)) {
                return Splash::log()->err(Splash::trans('ErrLocalInterface', $className, ConfiguratorInterface::class));
            }
        } catch (Exception $exc) {
            echo $exc->getMessage();

            return Splash::log()->err($exc->getMessage());
        }

        return true;
    }
355612
public static function autoload($className)
    {
        if (isset(self::$autoloadMap[$className])) {
            require self::$baseDir . self::$autoloadMap[$className];

            return true;
        }

        return false;
    }
168669
public function hasClass($class_name)
    {
        foreach ($this->nodes as $node) {
            if ($node instanceof \DOMElement && $node_class_attr = $node->getAttribute('class')) {
                $node_classes = explode(' ', $node_class_attr);
                if (\in_array($class_name, $node_classes, true)) {
                    return true;
                }
            }
        }

        return false;
    }
933224
public function checkRegistered($provider_name, $identifier) {
        $user = $this->user_repository->findbyAuth($provider_name, $identifier);
        return ($user !== null);
    }
502646
public function get_prefix($class_name){
        /** @var RestBase $class_name */
        if( !empty($class_name::$prefix) ){
            return $class_name::$prefix;
        }else{
            $seg = explode('\\', $class_name);
            $base = $seg[count($seg) - 1];
            return $this->str->camel_to_hyphen($base);
        }
    }
31795
public function isRegistered($name)
    {
        return
            array_key_exists($name, $this->services)
            || (
                isset($this->serviceProviders[$name])
                && $this->serviceProviders[$name] instanceof ServiceProviderInterface
            );
    }
728779
protected function get_class_setting( $class_name, $add_namespace = '' ) {
		if ( isset( $this->_cache[ $add_namespace . $class_name ] ) ) {
			return $this->_cache[ $add_namespace . $class_name ];
		}
		$namespaces = $this->get_namespaces();
		if ( ! empty( $namespaces ) ) {
			foreach ( $namespaces as $namespace ) {
				$class = rtrim( $namespace, '\\' ) . '\\' . $add_namespace . $class_name;
				if ( class_exists( $class ) ) {
					$this->_cache[ $add_namespace . $class_name ] = [ $class, $add_namespace ];

					return $this->_cache[ $add_namespace . $class_name ];
				}
			}
		}

		return false;
	}
694286
public function __isset($name)
    {
        // If the key was loaded, return true
        if (array_key_exists($name, $this->attributes)) {
            return true;
        }

        // If it is a not loaded relation, return true
        if ($this->isRelation($name)) {
            return true;
        }

        // At least return true if this key can be lazy loaded
        return $this->isLazyLoadKey($name);
    }
122777
protected function isNodeElementAware($class_name)
	{
		$node_element_aware_interface = 'QATools\\QATools\\PageObject\\Element\\INodeElementAware';

		if ( class_exists($class_name) ) {
			return in_array($node_element_aware_interface, class_implements($class_name));
		}

		return false;
	}
446272
public function _check($class)
    {
        $version = ObjectVersion::get($class);
        if ($version !== 0) {
            /*
             *  Execution of the application with database in N-1 and the application code in N
             *  Migration require
             */
            $migrateFunction = 'migrate_' . $version . '_' . ($version + 1);
            if (method_exists($class, $migrateFunction)) {

                return false;
            }
        } else {
            /*
             *  First execution of the application, jump from version 0 to N
             *  No migration needs
             */
            while(true) {
                $version = ObjectVersion::inc($class);

                $migrateFunction = 'migrate_' . $version . '_' . ($version + 1);
                if (method_exists($class, $migrateFunction) === false) {
                    break;
                }
            }
        }

        return true;
    }
157328
public static function load ($class_name)
	{
		$file_name = str_replace(self::MOLLIE_PREFIX, '', strtolower($class_name), $count);
		if (empty($count)) {
			return;
		}

		if (file_exists($file_name = __DIR__ . DIRECTORY_SEPARATOR . "$file_name.php")) {
			require $file_name;
		}
	}