Builds and return a Manager instance.

@return Manager
1229
public function build()
    {
        $annotationReader = $this->annotationReader;
        if (null === $annotationReader) {
            $annotationReader = new AnnotationReader();

            if (null !== $this->cacheDir) {
                $this->createDir($this->cacheDir . '/annotations');
                $annotationReader = new FileCacheReader($annotationReader, $this->cacheDir . '/annotations', $this->debug);
            }
        }

        $metadataDriver = $this->driverFactory->createDriver($this->metadataDirs, $annotationReader);
        $metadataFactory = new MetadataFactory($metadataDriver);

        $metadataFactory->setIncludeInterfaces($this->includeInterfaceMetadata);

        if (null !== $this->cacheDir) {
            $this->createDir($this->cacheDir . '/metadata');
            $metadataFactory->setCache(new FileCache($this->cacheDir . '/metadata'));
        }

        $schemaRegistry = new SchemaRegistry($this->schemaDirs);

        // TODO registry caching

        return new Manager($metadataFactory, $schemaRegistry);
    }
826104
private function registerSettingsManager()
    {
        $this->singleton(Contracts\Manager::class, function ($app) {
            return new SettingsManager($app);
        });

        $this->singleton(Contracts\Store::class, function ($app) {
            /** @var \Arcanedev\LaravelSettings\Contracts\Manager $manager */
            $manager = $app[Contracts\Manager::class];

            return $manager->driver();
        });
    }
840275
protected function getBucketManager()
    {
        if (!$this->bucketManager) {
            $this->bucketManager = new BucketManager($this->auth);
        }
        return $this->bucketManager;
    }
801753
public com.google.api.ads.adwords.axis.v201809.mcm.ManagedCustomer getManager() {
        return manager;
    }
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;
    }
950595
public function getManager($force = false)
    {
        if ($force === true) {
            $this->wipe();
        }

        if (!$this->manager instanceof ObjectManager) {
            $this->manager = $this->buildManager();
        }

        return $this->manager;
    }
166157
protected function get_privacy_manager() : manager {
        if (null === $this->manager) {
            $this->manager = new manager();
            $this->manager->set_observer(new \tool_dataprivacy\manager_observer());
        }

        return $this->manager;
    }
966207
public function build(): InspectWorkerRequest
	{
		$instance = new InspectWorkerRequest();
		if ($this->versionId === null) {
			throw new BuilderException('Property [versionId] is required.');
		}
		$instance->versionId = $this->versionId;
		return $instance;
	}
375830
private function createManager()
    {
        $config = $this->generateConfig();

        $algoliaManager = $this->algoliaFactory->make($config);
        $algoliaManager->setEnv($this->env);

        return $algoliaManager;
    }
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;
    }
1022365
public function getAnnotationManager()
    {
        if ($this->annotationManager) {
            return $this->annotationManager;
        }

        $this->setAnnotationManager(new AnnotationManager());
        return $this->annotationManager;
    }
7855
public function build()
    {
        $pm = new PluginManager($this->eventDispatcher);
        $pluginCollection = $pm->getPluginCollection();

        if (file_exists($this->path) === false) {
            return $pm;
        }

        $classnamesFromComposerFile = [];

        $finder = $this->buildFinder();

        foreach ($finder as $file) {
            if ($file->getFilename() === $this->composerFilename) {
                $classes = $this->getClassnamesFromComposerFile($file);
                $classnamesFromComposerFile = array_merge($classnamesFromComposerFile, $classes);

                continue;
            }

            $classname = $this->getClassnameFromPHPFilename($file);

            include_once $file->getRealPath();

            if ($this->hasImplementedPluginInterface($classname) === false) {
                continue;
            }

            $this->addPluginToCollection($classname, $pluginCollection);
        }

        foreach ($classnamesFromComposerFile as $classname) {
            if ($this->hasImplementedPluginInterface($classname) === true) {
                $this->addPluginToCollection($classname, $pluginCollection);
            }
        }

        return $pm;
    }
387583
protected function registerManager()
	{
		$me = $this;

		$this->app->bindShared('queue', function($app) use ($me)
		{
			// Once we have an instance of the queue manager, we will register the various
			// resolvers for the queue connectors. These connectors are responsible for
			// creating the classes that accept queue configs and instantiate queues.
			$manager = new QueueManager($app);

			$me->registerConnectors($manager);

			return $manager;
		});
	}
595782
public function getManager()
    {
        if (!is_object($this->_manager)) {
            $this->_manager = Yii::$app->get($this->_manager);
        }

        return $this->_manager;
    }
793041
public static function getInstance(ObjectConfigInterface $config, ObjectManagerInterface $manager)
    {
        //Add the object alias to allow easy access to the singleton
        $manager->registerAlias($config->object_identifier, 'dispatcher.fragment');

        //Merge alias configuration into the identifier
        $config->append($manager->getIdentifier('dispatcher.fragment')->getConfig());

        //Instantiate the class
        $instance  = new static($config);

        return $instance;
    }
652269
protected function registerManager()
    {
        $this->app->singleton('db', function () {
            $manager = new DataManager($this->app, $this->app['config']->get('database', []));

            // Driver Mongo
            $this->registerMongoDb($manager);

            return $manager;
        });
    }
642615
protected function buildManager()
    {
        $config = new Configuration;

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

        $documentManager = DocumentManager::create($this->getOption('connection'), $config, $this->getEventManager());

        if ($this->getRepositoryFactory() !== null) {
            $documentManager->setRepositoryFactory($this->getRepositoryFactory());
        }

        if ($this->getDefaultRepositoryClass() !== null) {
            $documentManager->setDefaultRepositoryClassName($this->getDefaultRepositoryClass());
        }

        return $documentManager;
    }