Get the static instance of this factory.

@return GeneratorAnswerBuilderFactory The static factory.
962728
public static function instance(): self
    {
        if (!self::$instance) {
            self::$instance = new self(
                InvocableInspector::instance(),
                Invoker::instance()
            );
        }

        return self::$instance;
    }
115407
protected function getNodeBuilder()
    {
        if (null === $this->nodeBuilder) {
            $this->nodeBuilder = new NodeBuilder();
        }

        return $this->nodeBuilder->setParent($this);
    }
647317
final public static function instance()
        {
            $className = get_called_class();

            if (!Arrays::exists(static::$instances[$className])) {
                static::$instances[$className] = new $className(func_get_args());
            }

            return static::$instances[$className];
        }
812653
private static function getInstance()
	{
		$accessor = static::getContainerAccessor();

		if (!isset(static::$instances[$accessor])) {
			$container = static::getContainer();
			static::$instances[$accessor] = $container[$accessor];
		}

		return static::$instances[$accessor];
	}
884158
public function getConcrete()
    {
        if ($this->instance) {
            return $this->instance;
        }

        if (is_object($this->concrete) || $this->concrete instanceof Closure) {
            $instance = $this->concrete;
        } else {
            $instance = $this->context->getContainer()->make($this->concrete);
        }

        if (! $this->isDynamic()) {
            $this->checkConcreteInstance($instance);
        }

        return $this->instance = $instance;
    }
1059944
protected function getAdapterFactory()
    {
        if (!isset($this->factoryCache[$this->id])) {
            $config = config('jwt');
            if (isset($this->config['adapter'])) {
                $config = array_merge($config, $this->config['adapter']);
            }
            $factoryClass = $this->getAdapterFactoryClass();
            $this->factoryCache[$this->id] = new $factoryClass($config);
        }
        return $this->factoryCache[$this->id];
    }
1240630
final public static function instance() {
        $c = get_called_class();
       
        if( ! isset( self::$instances[$c] ) )
        {
            self::$instances[$c] = new $c;
        }
       
        return self::$instances[$c];
    }
660566
public static function getDefault()
    {
        /** @var $factory Factory */
        $factory    = new static();
        $factory->addFactory(new CommitFactory(), 100)
                ->addFactory(new HeadFileFactory(), 80)
                ->addFactory(new DefaultFactory(), -100);
        return $factory;
    }
106723
public function getResolver()
    {
        if ($this->resolver instanceof Resolver) {
            return $this->resolver;
        }

        $factory = new Factory();
        $this->resolver = $factory->createCached($this->getDnsServer(), $this->getLoop());

        return $this->resolver;
    }
31238
protected function getGeneratorConfig()
    {
        if ($this->generatorConfig === null) {
            $this->generatorConfig = new GeneratorConfig();
            $this->generatorConfig->setBuildProperties($this->getProject()->getProperties());
        }

        return $this->generatorConfig;
    }
189061
public static function make()
    {
        $name = get_called_class();

        if (!isset(static::$instances[$name])) {

            $instance = new $name();

            static::$instances[$name] = method_exists($instance, 'boot') ? $instance->boot() : $instance;
        }

        return static::$instances[$name];
    }
567425
public static function getInstance() {

        // late-static-bound class name
        $classname = get_called_class();
        if (!isset(self::$instances[$classname])) {
            self::$instances[$classname] = new static;
        }
        return self::$instances[$classname];
    }
1326963
public static function instance(): self
    {
        if (!self::$instance) {
            self::$instance = new self(
                MatcherFactory::instance(),
                MatcherVerifier::instance(),
                GeneratorVerifierFactory::instance(),
                IterableVerifierFactory::instance(),
                ExceptionAssertionRecorder::instance(),
                AssertionRenderer::instance()
            );
        }

        return self::$instance;
    }
340101
public static function app()
    {
        if (!self::$instance){
            \wf\app\Benchmark::start();
            self::$instance = new static();
            self::$instance->initRuntime();
            \wf\app\Benchmark::mark('appInstanceAft');
        }

        return self::$instance;
    }
681018
static function factory()
    {
        if ( self::$factory === false )
        {
            self::$factory = true;
            self::instance()->readINISettings();
            eZImageAnalyzer::readAnalyzerSettingsFromINI();
        }
        return self::instance();
    }
1227634
public static function getILoggerFactory () {
    static $nop;
    if (null === self::$factory) {
      if (null == $nop) {
        $nop = new NOPLoggerFactory();
      }
      return $nop;
    }
    return self::$factory;
  }
378259
public static function getInstance()
    {
        if (is_null(self::$instance)) {
            throw new \RuntimeException('You must first create the singleton instance with createInstance().');
        }
        self::$instance->setGlobalsFromSugar();
        self::$instance->chdirToSugarDir();

        return self::$instance;
    }