Returns the configuration factory.

@return Configuration\ConfigurationFactory
337385
public function getConfigurationFactory()
    {
        if (null === $this->configurationFactory) {
            $this->configurationFactory = new Configuration\ConfigurationFactory();
        }

        return $this->configurationFactory;
    }
1022006
public function initFactoriedServices()
    {
        $config = $this->getConfig();
        if (!isset($config['service_manager'])) {
            return $this;
        }
        
        $smConfig = $config['service_manager'];
        if (!isset($smConfig['factories'])) {
            return $this;
        }
        $factories = $smConfig['factories']->toArray();
        $shared    = isset($smConfig['shared']) ? $smConfig['shared']->toArray() : [];
        foreach ($factories as $serviceName => $serviceConfig) {
            $isShare = isset($shared[$serviceName]) ? (bool) $shared[$serviceName] : true;
            $this->setServiceFactories($serviceName, $serviceConfig, $isShare);
        }

        return $this;
    }
216565
private function getFactoryConfig($factoryName)
    {
        if (isset($this->factories)) {
            $this->factories = $this->configToArray($this->factories);
            if (array_key_exists($factoryName, $this->factories)) {
                return $this->configToArray($this->factories[$factoryName]);
            }
        }

        return [];
    }
117974
private function getConfigEntityFactory()
    {
        if (!$this->_configEntityFactory instanceof IConfigEntityFactory) {
            throw new RequiredDependencyException(sprintf(
                'Config entity factory is not injected in class "%s".',
                get_class($this)
            ));
        }

        return $this->_configEntityFactory;
    }
511774
public function getConfig()
    {
        if(!$this->_config instanceof KObjectConfig) {
            $this->_config = new KObjectConfig($this->__config);
        }

        return $this->_config;
    }
121102
private function getViewFactory(): Factory
    {
        if ($this->factory) {
            return $this->factory;
        }

        $resolver = new EngineResolver();
        $resolver->register("blade", function () {
            $blade = $this->getCompiler();
            return new CompilerEngine($blade);
        });

        $this->factory = new Factory($resolver, $this->getViewFinder(), new Dispatcher());

        return $this->factory;
    }
735423
private static function getPuliFactory()
    {
        if (null === self::$puliFactory) {
            if (!defined('PULI_FACTORY_CLASS')) {
                throw new PuliUnavailableException('Puli Factory is not available');
            }

            $puliFactoryClass = PULI_FACTORY_CLASS;

            if (!ClassDiscovery::safeClassExists($puliFactoryClass)) {
                throw new PuliUnavailableException('Puli Factory class does not exist');
            }

            self::$puliFactory = new $puliFactoryClass();
        }

        return self::$puliFactory;
    }
199838
public FacesConfigFactoryType<WebFacesConfigDescriptor> getOrCreateFactory()
   {
      List<Node> nodeList = model.get("factory");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new FacesConfigFactoryTypeImpl<WebFacesConfigDescriptor>(this, "factory", model, nodeList.get(0));
      }
      return createFactory();
   }
954106
public function getConfiguration() {
    if ($this->getLocalPackage() === NULL) {
      $reader = new ConfigurationReader();

      // see ProjectsFactory
      return $reader->fromArray(
        $this->getHostConfiguration()->get(array('defaults'), array())
      );
    }
    
    return $this->getLocalProject()->getConfiguration();
  }
190934
public static Configuration getConfiguration(){
        if(configurations == null){
            configurations = ConfigurationFactory.getConfiguration();
            LOGGER.info("Initialized the Configurations.");
        }
        return configurations;
    }
146568
public static function factory($config = array())
	{
		$default = array();
		$required = array('base_url');
		$config = Inspector::prepareConfig($config, $default, $required);
		$client = new self($config->get('base_url'), $config->get('token'));
		$client->setConfig($config);
		$client->getEventDispatcher()->addSubscriber(new AuthenticationObserver());
		return $client;
	}
432779
protected function modelFactory()
    {
        if (!isset($this->modelFactory)) {
            throw new RuntimeException(sprintf(
                'Model Factory is not defined for "%s"',
                get_class($this)
            ));
        }

        return $this->modelFactory;
    }
731356
public function getConfig() {
		if ($this->_config !== null) {
			return $this->_config;
		}
		
		// Local config
		if ($this->_configLocal === null && method_exists($this, 'getLocalConfig') && $this->hasConfigsFactory()) {
			$localConfigSrc = $this->getLocalConfig();
			$configsFactory = $this->getConfigsFactory();

			if (is_array($localConfigSrc)) {
				$this->_configLocal = $configsFactory->create($localConfigSrc);
			}
			else if (is_string($localConfigSrc)) {
				$this->_configLocal = $configsFactory->createFromFile($localConfigSrc);
			}
			else {
				throw new NoConfig('Type of a local config\'s source must be an array or a string');
			}
			
			$this->_config = clone $this->_configLocal;
		}

		// Supplied config
		if ($this->_configSupplied === null && $this instanceof LocatorAwareInterface && $this->hasLocator()) {
			$locator  = $this->getLocator();
			$configId = $this->getConfigServiceId();
			
			if ($locator->has($configId)) {
				$this->_configSupplied = $locator->get($configId);
				
				if (! $this->_configSupplied instanceof ConfigInterface) {
					throw new NoConfig('Config must implement the "ConfigInterface"');
				}
			}
		}

		// Merge supplied config
		if ($this->_configSupplied !== null) {
			if ($this->_config === null) {
				$this->_config = clone $this->_configSupplied;
			} else {
				$this->_config = $this->_config->merge($this->_configSupplied);
			}
		}

		// Still no final config ?
		if ($this->_config === null) {
			throw new NoConfig('Unable to provide the config');
		}
		
		return $this->_config;
	}
96723
public function pathFactory()
    {
        if (null === $this->pathFactory) {
            $this->pathFactory = $this->createDefaultPathFactory();
        }

        return $this->pathFactory;
    }
922833
public function getConfigurationRegistry()
    {
        if (null === $this->configurationRegistry) {
            $this->configurationRegistry = new Configuration\ConfigurationRegistry();
        }

        return $this->configurationRegistry;
    }
1330219
public function createColumnFactory(): ColumnFactory {
		if (!($this->columnFactory)) {
			$this->columnFactory = new OracleColumnFactory($this);
		}
		return $this->columnFactory;
	}
1371584
public function getCacheFrontendFactory() {
		if ($this->_cacheFrontendFactory === null) {
			if ($this instanceof LocatorAwareInterface && $this->hasLocator()) {
				$locator   = $this->getLocator();
				$serviceId = $this->getCacheFrontendFactoryServiceId();
				
				if ($locator->has($serviceId)) {
					$this->_cacheFrontendFactory = $locator->get($serviceId);
					return $this->_cacheFrontendFactory;
				}
			}
			
			throw new NoFrontend('Unable to provide the cache frontend\'s factory');
		}
		
		return $this->_cacheFrontendFactory;
	}