returns the extension to where this class belongs too

@return  MoufReflectionExtension
778562
public function getExtension()
    {
        $extensionName  = $this->getExtensionName();
        if (null === $extensionName || false === $extensionName) {
            return null;
        }
        
        $moufRefExtension = new MoufReflectionExtension($extensionName);
        return $moufRefExtension;
    }
274774
private function getClassExtends()
    {
        if( $this->isMultiton() ) {
            $this->class->addUses('\Bond\Repository\Multiton as RM');
            $this->class->addExtends('RM');
        } else {
            $this->class->addUses('\Bond\Repository as R');
            $this->class->addExtends('R');
        }

    }
189808
protected function getExtensionManager()
    {
        if ($this->getServiceLocator()->has(common_ext_ExtensionsManager::SERVICE_ID)) {
            $service = $this->getServiceLocator()->get(common_ext_ExtensionsManager::SERVICE_ID);
        } else {
            $service = new common_ext_ExtensionsManager();
            $this->getServiceLocator()->propagate($service);
        }
        return $service;
    }
1322511
public function getExtension()
    {
        $pathInfo = pathinfo($this->getName());
        $extension = ExtensionGuesser::getInstance()->guess($this->getMimeType());
        if ($extension) {
            return $extension;
        } elseif (isset($pathInfo['extension'])) {
            return $pathInfo['extension'];
        }

        return null;
    }
541038
public function getExtension(): ?string
    {
        $exentension = pathinfo($this->path, PATHINFO_EXTENSION);

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

        return $exentension;
    }
465727
public function getExtension()
	{
		if (!isset($this->extension))
		{
			$bits = explode('.', $this->getName());
			if (count($bits) > 1)
			{
				$this->extension = end($bits);
			}
			else
			{
				$this->extension = '';
			}
		}

		return $this->extension;
	}
1179140
public function getDeclaringClassWithoutTraits()
    {
        $refClass = parent::getDeclaringClass();
        if ($refClass->getName() === $this->className) {
            if (null === $this->refClass) {
                $this->refClass = new MoufReflectionClass($this->className);
            }
            
            return $this->refClass;
        }
        
        $moufRefClass = new MoufReflectionClass($refClass->getName());
        return $moufRefClass;
    }
536426
public function actionIndex()
    {
        $extensions = Extension::find()->all();
        if (empty($extensions)) {
            echo "<empty list>";
        }
        echo"|";
        echo sprintf("%28s", "Class Name");
        echo"|";
        echo sprintf("%4s", "Enb");
        echo"|";
        echo sprintf("%4s", "Mnp");
        echo"|";
        echo sprintf("%4s", "Dft");
        echo"|";
        echo sprintf("%20s", "Create Time");
        echo"|";
        echo sprintf("%20s", "Update Time");
        echo"|";
        echo "\r\n";
        foreach ($extensions as $extension) {
            echo"|";
            echo sprintf("%28s", $extension->classname);
            echo"|";
            echo sprintf("%4d", $extension->isEnabled);
            echo"|";
            echo sprintf("%4d", $extension->monopolized);
            echo"|";
            echo sprintf("%4d", $extension->default);
            echo"|";
            echo sprintf("%20s", $extension->createdAt);
            echo"|";
            echo sprintf("%20s", $extension->updatedAt);
            echo"|";
            echo "\r\n";
        }
        return 0;
    }
360216
public function parentReflection()
    {
        $parentClass = $this->reflection->getParentClass();

        if (!empty($parentClass) && $parentClass->getName() != static::BASE_CLASS) {
            $parent = clone $this;
            $parent->reflection = $this->getParentClass();

            return $parent;
        }

        return null;
    }
674952
public function getInflector()
    {
        if (!isset($this->inflector)) {
            $this->inflector = new ClassNameInflector($this->getNamespace());
        }

        return $this->inflector;
    }
1124574
public function extension()
    {
        $atoms = $this->nameAtoms();
        $numParts = count($atoms);

        if ($numParts > 1) {
            return $atoms[$numParts - 1];
        }

        return null;
    }
544621
public function getProperties()
    {
        //$properties     = parent::getProperties();
        
        $moufProperties = array();
        foreach ($this->xmlRoot->property as $property) {
            $moufProperties[] = new MoufXmlReflectionProperty($this, $property);
        }
        
        return $moufProperties;
    }
444071
public function getExtensions()
    {
        if (null == $this->extensions_unserialized && null !== $this->extensions) {
            $this->extensions_unserialized = unserialize($this->extensions);
        }

        return $this->extensions_unserialized;
    }
38764
public T getDefaultExtension() {
        getExtensionClasses();
        if (null == cachedDefaultName || cachedDefaultName.length() == 0 || "true".equals(cachedDefaultName)) {
            return null;
        }
        return getExtension(cachedDefaultName);
    }
93067
protected function createOwnExtension()
    {
        $this->ownExtension = function (XType $type, $value, $view, $lang) {
            return $this->selfFormat($type, $value, $view, $lang);
        };
    }
1327861
public function getContentExtensions()
    {
        if (!empty($this->validExtensions)) {
            return $this->validExtensions;
        }

        return $this->validExtensions = $this->getContentTypeHandler()->getContentExtensions();
    }
1162757
public function getAvailableExtensions(): Extensions
    {
        if ($this->availableExtensions instanceof Extensions) {
            return $this->availableExtensions;
        }
        $foundExtensions  = $this->filesystemFinder->findExtensions();
        $storedExtensions = app('antares.installed') ? $this->extensionsRepository->all() : new Collection();

        foreach ($foundExtensions as $foundExtension) {
            $extension = $storedExtensions->first(function(ExtensionModel $extensionModel) use($foundExtension) {
                return $extensionModel->getFullName() === $foundExtension->getPackage()->getName();
            });

            $configFile = $foundExtension->getPath() . '/resources/config/settings.php';

            if ($this->filesystem->exists($configFile)) {
                $foundExtension->setSettings($this->settingsFactory->createFromConfig($configFile));
            }

            if ($extension instanceof ExtensionModel) {
                $foundExtension->setStatus($extension->getStatus());
                $foundExtension->setIsRequired($extension->isRequired());
                $foundExtension->getSettings()->updateData($extension->getOptions());
            }
        }

        return $this->availableExtensions = $foundExtensions;
    }