Return a named instance of EnvironmentCheckSuite.

@param string $name

@return EnvironmentCheckSuite
769178
public static function inst($name)
    {
        if (!isset(self::$instances[$name])) {
            self::$instances[$name] = new EnvironmentCheckSuite($name);
        }
        return self::$instances[$name];
    }
118878
public static function getInstance($name)
    {
        return (isset(self::$_pool[$name]) ? self::$_pool[$name] : self::create($name));
    }
68019
public function ensureRoleExists($name)
    {
        try {
            $role = $this->roleService->loadRoleByIdentifier($name);
        } catch (ApiExceptions\NotFoundException $e) {
            $roleCreateStruct = $this->roleService->newRoleCreateStruct($name);
            $roleDraft = $this->roleService->createRole($roleCreateStruct);
            $this->roleService->publishRoleDraft($roleDraft);
            $role = $this->roleService->loadRole($roleDraft->id);
        }

        return $role;
    }
436255
public static function suite($name, $fn)
    {
        $suite = new Suite(new InvocationContext(), $fn, $name);
        $suite->build();
        return $suite;
    }
1334081
public function createServer($name)
    {
        $server = new Server();
        if (in_array($name, $this->getKnownServers())) {
            $server
                ->setChecker(new Checker())
                ->setStartMultiLine($this->servers[$name]['directives']['start_multiline'])
                ->setEndMultiLine($this->servers[$name]['directives']['end_multiline'])
                ->setSimpleDirective($this->servers[$name]['directives']['simple'])
                ->setBinaries($this->servers[$name]['controlers'])
                ->setDetectionParameter($this->servers[$name]['switch']['detect'])
                ->setBeforeMethods($this->servers[$name]['parser']['before'])
                ->setAfterMethods($this->servers[$name]['parser']['after'])
                ->setDumperSimpleDirective($this->servers[$name]['dumper']['simple'])
                ->setDumperStartDirective($this->servers[$name]['dumper']['start_multiline'])
                ->setDumperEndDirective($this->servers[$name]['dumper']['end_multiline'])
                ->setKnownDirectives($this->servers[$name]['known_directives'])
            ;
        }

        return $server;
    }
1134065
public function getField($name)
    {
        $namedField = null;
        $fields     = $this->getFields();
        foreach ($fields as $field) {
            if ($field->getName() == $name) {
                $namedField = $field;
                break;
            }
        }
        return $namedField;
    }
372490
public function getEnvironment($name)
    {
        if (isset($this->environments[$name])) {
            return $this->environments[$name];
        }

        // check the environment exists
        if (!$this->getConfig()->hasEnvironment($name)) {
            throw new \InvalidArgumentException(sprintf(
                'The environment "%s" does not exist',
                $name
            ));
        }

        // create an environment instance and cache it
        $envOptions = $this->getConfig()->getEnvironment($name);
        $envOptions['version_order'] = $this->getConfig()->getVersionOrder();

        $environment = new Environment($name, $envOptions);
        $this->environments[$name] = $environment;
        $environment->setCommand($this->getCommand());

        return $environment;
    }
1115029
public static function getInstance(string $name)
    {
        if (!isset(self::$instances[$name]) || empty(self::$instances[$name])) {
            new static($name);
        }
        return (self::$instances[$name]);
    }
318467
protected function env($name, $defaultValue = null)
    {
        $value = getenv($name);

        if (null === $value || false === $value) {
            return $defaultValue;
        }

        return $value;
    }
1359097
static public function instance($name=null)
    {
        $options = $name ? ['name' => $name] : [];
        $name = $name ?: get_called_class();
        
        if (!isset(static::$instances[$name])) {
            static::$instances[$name] = new static($name);
        }
        
        return static::$instances[$name];
    }
356122
public static function getInstance($name)
    {
        if (is_null(self::$instance)) {
            $arr = explode('.', $name);
            $company = $arr[0];
            $type = $arr[1];
            $className = self::$map[$company][$type];
            self::$instance = new $className;
        }

        return self::$instance;
    }
626239
protected function getConfigFile($name = 'app')
    {
        $env = $this->option('env') ? $this->option('env').'/' : '';

        $name .= '.php';

        $contents = File::get($path = $this->laravel['path.config']."/{$env}{$name}");

        return $path;
    }
1266532
private function readEnvironmentVariable($name){
		if (isset($_SERVER[$name])) {
			return $_SERVER[$name];
		} else if (isset($_SERVER[strtolower($name)])) {
			return $_SERVER[strtolower($name)];
		} else {
			return null;
		}
	}
288086
public static function env(String $name = NULL, $value = NULL)
    {
        return self::_method($name, $value, $_ENV, __FUNCTION__);
    }
441290
public static function getInstance(string $name): \Swoole\Atomic
    {
        if(!static::$isInited)
        {
            throw new \RuntimeException('getInstance failed, AtomicManager is not initialized');
        }
        if(!isset(static::$atomics[$name]))
        {
            throw new \RuntimeException(sprintf('GetInstance failed, %s is not found', $name));
        }
        return static::$atomics[$name];
    }
882381
private static function createNamedInstance(string $name)
    {
        $class = self::findParentClassForConst($name);

        $key = self::getConstKey($class, $name);

        if (!array_key_exists($key, self::$instances)) {
            self::$instances[$key] = new static($name);
        }

        return self::$instances[$key];
    }
35020
public function getBackup($name = null)
    {
        $name = $name ?? 'default';

        if (!$this->backupExists($name)) {
            throw new \Hail\Image\Exception\RuntimeException(
                "Backup with name ({$name}) not available. Call backup() before reset()."
            );
        }

        return $this->backups[$name];
    }