Get the factory object for converters to and from PostreSQL representation

@return TypeConverterFactory
358128
public function getTypeConverterFactory(): TypeConverterFactory
    {
        if (!$this->converterFactory) {
            $this->setTypeConverterFactory(new converters\DefaultTypeConverterFactory());
        }
        return $this->converterFactory;
    }
261340
protected function prepareConverters($sql)
    {
        foreach ($this->getParametersType($sql) as $index => $type) {
            if ($type === '') {
                $this->converters[$index] = null;
            } else {
                $converter = $this
                    ->getSession()
                    ->getClientUsingPooler('converter', $type)
                    ->getConverter()
                    ;

                $this->converters[$index] = function ($value) use ($converter, $type) {
                    return $converter->toPgStandardFormat($value, $type, $this->getSession());
                };
            }
        }

        return $this;
    }
1082577
final protected function templateFactory()
    {
        if ($this->templateFactory === null) {
            throw new RuntimeException(sprintf(
                'Template Factory is not defined for [%s]',
                get_class($this)
            ));
        }

        return $this->templateFactory;
    }
450625
public function proto()
    {
        $objType = $this->objType();
        if (!$objType) {
            throw new RuntimeException('Can not create prototype, object type is undefined');
        }

        return $this->modelFactory()->get($objType);
    }
1152712
def GetConvertersByClass(value_cls):
    """"""
    try:
      return ExportConverter.converters_cache[value_cls]
    except KeyError:
      results = [
          cls for cls in itervalues(ExportConverter.classes)
          if cls.input_rdf_type == value_cls
      ]
      if not results:
        results = [DataAgnosticExportConverter]

      ExportConverter.converters_cache[value_cls] = results
      return results
605636
public function parameterValidatorFactory()
    {
        return function (ServiceContainer $container) {
            $parameterValidator = new ParameterValidator(
                $container->get('ecomdev.phpspec.magento_di_adapter.code_generator.io'),
                $container->get('ecomdev.phpspec.magento_di_adapter.code_generator.defined_classes'),
                $container->get('loader.transformer.typehintindex')
            );

            $parameterValidator
                ->addGenerator(Generator\Factory::class, Generator\Factory::ENTITY_TYPE)
                ->addGenerator(Generator\Repository::class, Generator\Repository::ENTITY_TYPE)
                ->addGenerator(Generator\Converter::class, Generator\Converter::ENTITY_TYPE)
                ->addGenerator(Generator\Persistor::class, Generator\Persistor::ENTITY_TYPE)
                ->addGenerator(MapperGenerator::class, MapperGenerator::ENTITY_TYPE)
                ->addGenerator(SearchResults::class, SearchResults::ENTITY_TYPE)
            ;

            return $parameterValidator;
        };
    }
479765
@Override
    public Converter getConverter(Class<?> valueType) {
        ConverterProvider provider = findProvider(valueType);
        if (provider == null) {
            return null;
        }
        return provider.createConverter(valueType);
    }
91544
protected function getSubtypeConverter($type, Session $session)
    {
        if (!isset($this->converters[$type])) {
            $this->converters[$type] = $session
                ->getClientUsingPooler('converter', $type)
                ->getConverter()
                ;
        }

        return $this->converters[$type];
    }
1355196
public function getAdapterFactoryClass()
    {
        $config = config('jwt');
        if (!isset($config['adapter'])) {
            $config['adapter'] = 'lcobucci';
        }
        if (class_exists($config['adapter'])) {
            $factoryClass = $config['adapter'];
        } else {
            $factoryClass = 'Canis\Lumen\Jwt\Adapters\\' . ucfirst($config['adapter']) . '\Factory';
            if (!class_exists($factoryClass)) {
                throw new InvalidAdapterException("{$config['adapter']} is not available");
            }
        }
        return $factoryClass;
    }
755244
public function getFormFactory()
    {
        if ($this->formFactory) {
            return $this->formFactory;
        }

        $this->formFactory = new Factory();
        return $this->formFactory;
    }
846300
private static function getFactory(string $type)
    {
        if (!empty(self::$factories[$type])) {
            return self::$factories[$type];
        }

        if (!empty(self::$factory)) {
            return self::$factories[$type] = self::$factory;
        }

        foreach (self::$strategies as $className) {
            if (is_array($className) && isset($className[$type])) {
                $className = $className[$type];

                if (class_exists($className)) {
                    return self::$factories[$type] = new $className();
                }

                continue;
            }

            if (!class_exists($className)) {
                continue;
            }

            if (strpos($className, __NAMESPACE__) === 0 && !$className::isInstalled()) {
                continue;
            }

            return self::$factories[$type] = self::$factory = new $className();
        }

        throw new RuntimeException('No PSR-7 library detected');
    }
771522
public function createMetaEntityFactory(): MetaEntityFactory {
		if (!isset($this->metaEntityFactory)) {
			$this->metaEntityFactory = new PgsqlMetaEntityFactory($this);
		}
		
		return $this->metaEntityFactory;
	}
449507
protected function getViewHelperFactory()
    {
        $factory = $this->getPrototype(
                $this->viewHelperFactoryClass,
                ['umi\templating\extension\helper\IHelperFactory']
            )
            ->createInstance();

        if ($factory instanceof IModelAware && $this->modelFactory) {
            $factory->setModelFactory($this->modelFactory);
        }

        return $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;
    }
658139
public function getHeaderFactory()
    {
        if ($this->headerFactory === null) {
            $this->headerFactory = new HeaderFactory($this->getConsumerService());
        }
        return $this->headerFactory;
    }
726615
@SuppressWarnings("unchecked")
	public <T> Converter<T> getDefaultConverter(Type type) {
		return (null == defaultConverterMap) ? null : (Converter<T>) defaultConverterMap.get(type);
	}
320693
public function get_supported_conversions() {
        $classname = self::get_classname($this->name);
        if (class_exists($classname)) {
            $object = new $classname();
            return $object->get_supported_conversions();
        }
        return '';
    }