Get the EntityManager(Metadata)Provider

@return \Concrete\Core\Database\EntityManager\Provider\DefaultPackageProvider|\Concrete\Core\Package\Package
12860
public function getEntityManagerProvider()
    {
        if ($this->pkg instanceof ProviderInterface) {
            $provider = $this->pkg;
        } elseif ($this->pkg instanceof ProviderAggregateInterface) {
            $provider = $this->pkg->getEntityManagerProvider();
        } else {
            $provider = new DefaultPackageProvider($this->app, $this->pkg);
        }

        return $provider;
    }
1044188
public function getSetManager()
    {
        if (!isset($this->setManager)) {
            $this->setManager = new ExpressSetManager($this->expressEntity, $this->entityManager);
        }

        return $this->setManager;
    }
1209297
public function getRendererManager()
    {
        if (!$this->rendererManager) {
            $this->rendererManager = $this->getPackage()->getContainer()->get('renderer.manager');
        }

        return $this->rendererManager;
    }
1279078
public function getDefaultProvider()
    {
        if (isset($this->defaultProvider)) {
            return $this->getProvider($this->defaultProvider);
        }

        $providerLabels = array_keys($this->providers);

        return $this->providers[$providerLabels[0]];
    }
1243767
public function getEntityManager()
    {

        // check if we have a valid datasource node
        if ($this->getDatasourceNode() == null) {
            return;
        }

        // prepare the path to the entities
        $absolutePaths = array();
        if ($relativePaths = $this->getStepNode()->getParam(AbstractDatabaseStep::PARAM_PATH_TO_ENTITIES)) {
            foreach (explode(PATH_SEPARATOR, $relativePaths) as $relativePath) {
                $absolutePaths[] = $this->getWebappPath() . DIRECTORY_SEPARATOR . $relativePath;
            }
        }

        // load the database connection parameters
        $connectionParameters = $this->getConnectionParameters();

        // initialize and load the entity manager and the schema tool
        $metadataConfiguration = Setup::createAnnotationMetadataConfiguration($absolutePaths, true, null, null, false);
        return EntityManager::create($connectionParameters, $metadataConfiguration);
    }
441960
public function getModuleManager()
    {
        if (null === $this->moduleManager) {
            $this->moduleManager = $this->serviceManager->get('ModuleManager');
        }

        return $this->moduleManager;
    }
900881
protected function getManager()
	{
		if( $this->manager === null ) {
			$this->manager = \Aimeos\MAdmin\Cache\Manager\Factory::createManager( $this->getContext() );
		}

		return $this->manager;
	}
1132581
public function getServicePluginManager()
	{
	    if($this->servicePluginManager === null){
	        $this->servicePluginManager = new ServicePluginManager();
	        $that = $this;
	
	        $this->servicePluginManager->addInitializer(function ($instance, $serviceManager) use ($that) {
	             
	            $name     = $serviceManager->getCreationInstanceName();
	            $options  = $serviceManager->getCreationInstanceOptions();
	             
	            /**
	             * Configure service
	            */
	            if($options !== null && sizeof($options) &&
	               $instance instanceof Feature\ConfigurableInterface){
	
	                $instance->setConfig($options);
	            }
	        });
	    }
	     
	    return $this->servicePluginManager;
	}
1306237
protected function getConfigurationManager()
	{
		if (!isset($this->configurationManager)) {
			$this->configurationManager = GeneralUtility::makeInstance(ObjectManager::class)
				->get(ConfigurationManager::class);
		}
		return $this->configurationManager;
	}
813381
public function bootPackageEntityManager(Package $p, $clearCache = false)
    {
        $configUpdater = new EntityManagerConfigUpdater($this->entityManager);
        $providerFactory = new PackageProviderFactory($this->application, $p);
        $provider = $providerFactory->getEntityManagerProvider();
        $configUpdater->addProvider($provider);
        if ($clearCache) {
            $cache = $this->entityManager->getConfiguration()->getMetadataCacheImpl();
            if ($cache) {
                $cache->flushAll();
            }
        }
    }
1013347
protected function getMetadataImporter()
    {
        if (! $this->metadataImporter) {
            $this->metadataImporter = $this->getServiceLocator()->get(MetadataService::SERVICE_ID)->getImporter();
        }
        return $this->metadataImporter;
    }
949816
private function getMetadataDriver()
    {
        if (null === $this->driver) {
            $metadataDirs = $this->getMetadataDirs();

            $annotationDriver = new AnnotationDriver($this->reader);
            if (!empty($metadataDirs)) {
                $fileLocator = new FileLocator($metadataDirs);
                $ymlDriver = new YamlDriver($fileLocator);
                $this->driver = new DriverChain(array(
                    $ymlDriver,
                    $annotationDriver,
                ));

                $ymlDriver->setDriver($this->driver);
            }
            else {
                $this->driver = $annotationDriver;
            }
        }

        return $this->driver;
    }
1160422
public static function getEntityManager($context = null)
    {
        $class = static::cleanClassNamespace(get_called_class()).'Manager';
        $refl = new ReflectionClass($class);

        return App::get($refl->getConstant('SERVICE'));
    }
200528
protected function buildManager()
    {
        $config = new Configuration();

        $this->setUpGeneralConfigurations($config);
        $this->setUpSpecificConfigurations($config);

        $eventManager = $this->getEventManager();
        if ($this->getEventSubscribers() !== null) {
            /* @var array $eventSubscribers */
            $eventSubscribers = $this->getEventSubscribers();

            foreach ($eventSubscribers as $eventSubscriber) {
                $eventManager->addEventSubscriber($eventSubscriber);
            }
        }

        $entityManager = EntityManager::create($this->getOption('connection'), $config, $eventManager);

        $customMappingTypes = $this->getCustomMappingTypes();

        $platform = $entityManager->getConnection()->getDatabasePlatform();
        foreach ($this->getCustomTypes() as $type => $class) {
            if (Type::hasType($type)) {
                Type::overrideType($type, $class);
            } else {
                Type::addType($type, $class);
            }

            $platform->registerDoctrineTypeMapping(
                $type,
                array_key_exists($type, $customMappingTypes) ? $customMappingTypes[$type] : $type
            );
        }

        return $entityManager;
    }
421563
public function getLoader()
    {
        if (null === $this->loader) {
            $locator  = new FileLocator($this->paths);
            $resolver = new LoaderResolver(array(
                new YamlFileLoader($locator),
                new PhpFileLoader($locator),
                new IniFileLoader($locator),
                new ArrayLoader(),
            ));

            $this->loader = new DelegatingLoader($resolver);
        }

        return $this->loader;
    }
985690
public function getInstallationManager()
    {
        if (!$this->started) {
            throw new LogicException('Puli was not started');
        }

        if (!$this->installationManager && $this->context instanceof ProjectContext) {
            $this->installationManager = new InstallationManagerImpl(
                $this->getContext(),
                $this->getRepository(),
                $this->getServerManager()->getServers(),
                $this->getInstallerManager()
            );
        }

        return $this->installationManager;
    }
901549
public function getPluginManager()
    {
        if (null === $this->plugins) {
            $this->setPluginManager(new Navigation\PluginManager());
        }
        return $this->plugins;
    }