Get default extension class instance.

@return GendoriaCommandQueueExtension
188902
public function getContainerExtension()
    {
        if (null === $this->extension || false === $this->extension) {
            $this->extension = new GendoriaCommandQueueExtension();
        }

        return $this->extension;
    }
738100
public static function for_extension($extension)
    {
        $classes = ClassInfo::subclassesFor(DataFormatter::class);
        array_shift($classes);
        $sortedClasses = [];
        foreach ($classes as $class) {
            $sortedClasses[$class] = Config::inst()->get($class, 'priority');
        }
        arsort($sortedClasses);
        foreach ($sortedClasses as $className => $priority) {
            $formatter = new $className();
            if (in_array($extension, $formatter->supportedExtensions())) {
                return $formatter;
            }
        }
    }
1224836
public function getExtension()
    {
        if (version_compare(PHP_VERSION, '5.3.6') >= 0) {
            return parent::getExtension();
        } else {
            return ltrim(pathinfo($this->getAbsolutePath(), PATHINFO_EXTENSION), '.');
        }
    }
85132
public function extensions()
    {
        foreach ($this->extensionsToCheck as $extension) {
            $extensions[$extension] = extension_loaded($extension);
        }

        return $extensions;
    }
979886
public static function getExtension(
        string $type,
        string $default = "unknown"
    ): string
    {
        return array_key_exists($type, self::$types)
            ? self::$types[$type]
            : $default;
    }
455729
public function getDefault()
    {
        // get the memoized default
        if ($this->default) {
            return $this->get($this->default);
        }

        // no configurations available
        // check for existing connections
        if (0 === count($this->config)) {
            if (1 === count($this->connections)) {
                $this->default = array_keys($this->connections)[0];

                return $this->get($this->default);
            } elseif (count($this->connections) > 1) {
                throw new JAQBException('Could not determine the default connection because multiple connections were available and the default has not been set.');
            }

            throw new JAQBException('The default connection is not available because no configurations have been supplied.');
        }

        // handle the case where there is a single configuration
        if (1 === count($this->config)) {
            $this->default = array_keys($this->config)[0];

            return $this->get($this->default);
        }

        // handle multiple configurations
        foreach ($this->config as $k => $v) {
            if (array_value($v, 'default')) {
                $this->default = $k;

                return $this->get($this->default);
            }
        }

        throw new JAQBException('There is no default connection.');
    }
541038
public function getExtension(): ?string
    {
        $exentension = pathinfo($this->path, PATHINFO_EXTENSION);

        if (is_blank($exentension)) {
            return null;
        };

        return $exentension;
    }
695589
public function getDefault() {
    	if ($this->isPublic() && !$this->isStatic() && $this->refClass->isAbstract() == false) {	    		 
	  		$className = $this->refClass->getName();
	  		// TODO: find a way to get default value for abstract properties.
	  		// TODO: optimize this: we should not have to create one new instance for every property....
	  		/*$instance = new $className();
			$property = $this->getName();
	    	return $instance->$property;*/
	  		
	  		// In some cases, the call to getDefaultProperties can log NOTICES
	  		// in particular if an undefined constant is used as default value.
	  		ob_start();
	  		$defaultProperties = $this->refClass->getDefaultProperties();
	  		$possibleError = ob_get_clean();
			if ($possibleError) {
				throw new \Exception($possibleError);	
			}
	  		return $defaultProperties[$this->getName()];
    	} else {
    		return null;
    	}
    }
98588
public function getExtensionProperty($property, $default = null)
	{
		$extension = new Registry((array) $this->getExtension());

		return $extension->get($property, $default);
	}
1007094
public static function getDefault()
    {
        if (static::$_default != null) {
            return static::$_default;
        }

        // check if running into laravel context
        if (Context::checkLaravel()) {
            static::$_default = new self(['socket' => 'Laravel']);

            return static::$_default;
        }

        // check if registered container
        if (Context::checkContainer()) {
            return Context::getContainerDatabase();
        }
    }
362307
public function getDefaultQueryBuilder()
    {
        $em = $this->getEntityManager();
        return $em->createQueryBuilder()
            ->select('n')
            ->from($this->getClassname(), 'n');
    }
389318
public function get_extension()
	{
		if ($this->link !== null)
		{
			$url = SimplePie_Misc::parse_url($this->link);
			if ($url['path'] !== '')
			{
				return pathinfo($url['path'], PATHINFO_EXTENSION);
			}
		}
		return null;
	}
1186727
public function getExtensionInstance($extension)
    {
        $instances = $this->getExtensionInstances();
        if (array_key_exists($extension, $instances)) {
            return $instances[$extension];
        }
        // in case Injector has been used to replace an extension
        foreach ($instances as $instance) {
            if (is_a($instance, $extension)) {
                return $instance;
            }
        }
        return null;
    }
361729
public function getExtensions()
  {
    $ext = array();

    foreach ($this->Config->get('file-extensions') as $key => $value)
    {
      $ext = array_merge($ext, $value['extensions']);
    }

    return $ext;
  }
457032
public static function getExtensionClass(string $name): string
    {
        $class = "";
        if (empty($name) === false && empty(self::$extension_classes[$name]) === false) {
            $class = self::$extension_classes[$name];
        }
        return $class;
    }
895566
private function getShownExtension()
    {
        if($this->hasRequestParameter('shownExtension')){
            $shownExtension = $this->getRequestParameter('shownExtension');
            if(strlen(trim($shownExtension)) > 0){
                $extension = $this->getExtension($shownExtension);
                return $extension->getName();
            }
        }
        return null;
    }
803446
public function getDefault()
    {
        $category = $this->getCategory();

        $categoryConfig = $this->getCategoryConfig($category);

        if (!isset($categoryConfig[ModelInterface::DEFAULT_CONTEXT])) {
            throw new DefaultMissingException(
                'ConfigModel requires default to be set'
            );
        }

        return $categoryConfig[ModelInterface::DEFAULT_CONTEXT];
    }