Retrieve the LdapObjectManager for the current domain context.

@return LdapObjectManager
334383
protected function getObjectManager()
    {
        if (!isset($this->ldapObjectManager[$this->context])) {
            $this->ldapObjectManager[$this->context] = new LdapObjectManager(
                $this->getConnection(),
                $this->getSchemaFactory(),
                $this->config->getEventDispatcher()
            );
        }

        return $this->ldapObjectManager[$this->context];
    }
151908
public function getLanguageManager()
    {
        if ($this->languageManager != null) {
            return $this->languageManager;
        }

        $this->languageManager = new LanguageManager($this->getLanguageService());

        if ($this->logger) {
            $this->languageManager->setLogger($this->logger);
        }

        return $this->languageManager;
    }
874989
public function getRoleMapper()
    {
        if (null === $this->roleMapper) {
            $this->roleMapper = $this->getServiceManager()->get('playgrounduser_role_mapper');
        }

        return $this->roleMapper;
    }
293195
private function getManager(string $resourceClass, $data): ?ObjectManager
    {
        $objectManager = $this->managerRegistry->getManagerForClass($resourceClass);
        if (null === $objectManager || !\is_object($data)) {
            return null;
        }

        return $objectManager;
    }
1213611
public LdapContext getInnermostDelegateLdapContext() {
        final LdapContext delegateLdapContext = this.getDelegateLdapContext();

        if (delegateLdapContext instanceof DelegatingLdapContext) {
            return ((DelegatingLdapContext)delegateLdapContext).getInnermostDelegateLdapContext();
        }

        return delegateLdapContext;
    }
1087850
@Override
    public RegistrationManager getRegistrationManager(){
        if(registrationManager == null){
            synchronized(this){
                if(registrationManager == null){
                    RegistrationManagerImpl registration = new RegistrationManagerImpl(getDirectoryServiceClientManager());
                    registration.start();
                    registrationManager = registration;
                }
            }
        }
        return registrationManager;
    }
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);
    }
283553
public function getServer()
    {
        $servers = $this->getSortedServersArray();

        foreach ($servers as $server) {
            if ($this->isServerAvailable($server)) {
                return $server;
            }
        }

        throw new LdapConnectionException('No LDAP server is available.');
    }
777001
public function getSecurityManager()
    {
        if(array_key_exists(self::SECURITY_MANAGER, $this->_map))
            return $this->_map[self::SECURITY_MANAGER];
        return null;

    }
84902
public function getObjectMappingMapper()
    {
        if (null === $this->objectMappingMapper) {
            $this->objectMappingMapper = $this->serviceLocator->get('playgroundflow_objectmapping_mapper');
        }
    
        return $this->objectMappingMapper;
    }
1271347
protected Object _getCacheManager() {
        net.sf.ehcache.CacheManager cacheManager = net.sf.ehcache.CacheManager.getInstance();
        if (cacheManager != null)
            return cacheManager;
        return net.sf.ehcache.CacheManager.newInstance();
    }
436163
protected function getEntityManager()
    {
        if (null === $this->entityManager) {
            $reflectionProperty = new \ReflectionProperty(SQLFilter::class, 'em');
            $reflectionProperty->setAccessible(true);
            $this->entityManager = $reflectionProperty->getValue($this);
        }

        return $this->entityManager;
    }
104670
public function getNestedSetManager()
    {
        if (!$this->nestedSetManager instanceof NestedSet\Manager) {
            $this->setNestedSetManager($this->getServiceLocator()->get('dlccategory_nestedset_manager'));
        }
        return $this->nestedSetManager;
    }
1344985
public static PluginManager getInstance() {
        if (_instance == null) {
            _instance = new PluginManager();
            _instance.classInformation = new HashMap<String, ClassInformation>();
            _instance.methodInformation = new HashMap<String, com.groupon.odo.proxylib.models.Method>();
            _instance.jarInformation = new ArrayList<String>();

            if (_instance.proxyLibPath == null) {
                //Get the System Classloader
                ClassLoader sysClassLoader = Thread.currentThread().getContextClassLoader();

                //Get the URLs
                URL[] urls = ((URLClassLoader) sysClassLoader).getURLs();

                for (int i = 0; i < urls.length; i++) {
                    if (urls[i].getFile().contains("proxylib")) {
                        // store the path to the proxylib
                        _instance.proxyLibPath = urls[i].getFile();
                        break;
                    }
                }
            }
            _instance.initializePlugins();
        }
        return _instance;
    }
278865
protected function getObjectManagerService(ServiceLocatorInterface $serviceLocator, $objectManagerServiceName)
    {
        $config = $serviceLocator->get('config');

        if (! $objectManagerServiceName && isset($config['thorr_persistence_dmm']['doctrine']['object_manager'])) {
            $objectManagerServiceName = $config['thorr_persistence_dmm']['doctrine']['object_manager'];
        }

        $objectManager = $objectManagerServiceName && $serviceLocator->has($objectManagerServiceName) ?
            $serviceLocator->get($objectManagerServiceName)
            : null;

        if (! $objectManager instanceof ObjectManager) {
            throw new Exception\InvalidServiceNameException(sprintf(
                'Invalid object manager type: "%s" is not a subtype of "%s"',
                is_object($objectManager) ? get_class($objectManager) : gettype($objectManager),
                ObjectManager::class
            ));
        }

        return $objectManager;
    }
1022365
public function getAnnotationManager()
    {
        if ($this->annotationManager) {
            return $this->annotationManager;
        }

        $this->setAnnotationManager(new AnnotationManager());
        return $this->annotationManager;
    }
1374897
public function getObjectManager(): ObjectManagerInterface
    {
        if (!isset($this->earlyInstances[ObjectManagerInterface::class])) {
            debug_print_backtrace();
            throw new FlowException('The Object Manager is not available at this stage of the bootstrap run.', 1301120788);
        }
        return $this->earlyInstances[ObjectManagerInterface::class];
    }