Get type converter collection that will be used for the \SoapClient

@return TypeConverterCollection
347655
public function getTypeConverters()
    {
        if (null === $this->typeConverters) {
            $this->typeConverters = new TypeConverterCollection(
                array(
                    new DateTimeTypeConverter()
                )
            );
        }

        return $this->typeConverters;
    }
377147
public function getConverterForType($type)
    {
        if (!$this->hasType($type)) {
            throw new ConverterException(
                sprintf(
                    "No converters associated with type '%s'. Handled types are {%s}.",
                    $type,
                    join(', ', $this->getTypes())
                )
            );
        }

        return $this->converters[$this->types[$type]];
    }
1300596
public function get(string $type): array
    {
        try {
            return $this->converters[$this->resolveType($type)];
        } catch (\Throwable $t) {
            throw new InvalidTypeConverterException(
                sprintf('Invalid converter type `%s`.', $type)
            );
        }
    }
42042
public function getTypes() {
    // If type hint is set then that is the type of the parameter.
    if ($this->typeHint) {
      if ($this->typeHint instanceof TokenNode) {
        if ($this->typeHint->getType() === T_ARRAY) {
          $docTypes = $this->getDocTypes();
          foreach ($docTypes as $docType) {
            if ($docType !== 'array' && substr($docType, -2) !== '[]') {
              return [$this->typeHint->getText()];
            }
          }
          return $docTypes;
        }
        else {
          return [$this->typeHint->getText()];
        }
      }
      else {
        return [$this->typeHint->getAbsolutePath()];
      }
    }
    return $this->getDocTypes();
  }
165972
public static function getTypes()
    {
        return [
            self::TYPE_VCS,
            self::TYPE_GIT,
            self::TYPE_GIT_BITBACKET,
            self::TYPE_GITHUB,
            self::TYPE_GITLAB,
        ];
    }
1374837
public function getSoapTypes()
    {
        if (null === $this->types) {

            $soapTypes = $this->__getTypes();
            foreach ($soapTypes as $soapType) {
                $properties = array();
                $lines = explode("\n", $soapType);
                if (!preg_match('/struct (.*) {/', $lines[0], $matches)) {
                    continue;
                }
                $typeName = $matches[1];

                foreach (array_slice($lines, 1) as $line) {
                    if ($line == '}') {
                        continue;
                    }
                    preg_match('/\s* (.*) (.*);/', $line, $matches);
                    $properties[$matches[2]] = $matches[1];
                }

                // Since every object extends sObject, need to append sObject elements to all native and custom objects
                if ($typeName !== 'sObject' && array_key_exists('sObject', $this->types)) {
                    $properties = array_merge($properties, $this->types['sObject']);
                }

                $this->types[$typeName] = $properties;
            }
        }

        return $this->types;
    }
840425
protected function _getTypeItem()
	{
		if( !isset( $this->_typeItem ) )
		{
			$typeManager = MShop_Factory::createManager( $this->_getContext(), 'customer/list/type' );


			$search = $typeManager->createSearch( true );
			$expr = array(
				$search->compare( '==', 'customer.list.type.code', 'watch' ),
				$search->getConditions(),
			);
			$search->setConditions( $search->combine( '&&', $expr ) );

			$types = $typeManager->searchItems( $search );

			if( ( $typeItem = reset( $types ) ) === false ) {
				throw new Client_Html_Exception( sprintf( 'List type "%1$s" is not available', 'watch' ) );
			}

			$this->_typeItem = $typeItem;
		}

		return $this->_typeItem;
	}
869698
protected function getFieldTypes()
    {
        return (new Collection($this->getFields()))
            ->map(function ($options) {
                return $options['type'];
            })
            ->values()
            ->unique()
            ->map(function ($type) {
                return self::$types[$type];
            });
    }
239719
public function getTypes()
    {
        $handlers = &gplcart_static('price.rule.types');

        if (isset($handlers)) {
            return $handlers;
        }

        $handlers = gplcart_config_get(GC_FILE_CONFIG_PRICE_RULE_TYPE);
        $this->hook->attach('price.rule.types', $handlers, $this);
        return $handlers;
    }
47933
protected function getCollection(): Collection
    {
        $conn = $this->connPool->getConnection();
        $database = $conn->defaultDatabase;
        $collection = $this->schema->collection;

        return $conn->getRawConnection()->$database->$collection;
    }
946472
def get_default_collection_converters(conversion_finder: ConversionFinder) -> List[Union[Converter[Any, dict], Converter[dict, Any]]]:
    
    return [ConverterFunction(from_type=List, to_type=Set, conversion_method=list_to_set, custom_name='list_to_set',
                              function_args={'conversion_finder': conversion_finder}),
            ConverterFunction(from_type=List, to_type=Tuple, conversion_method=list_to_tuple,
                              custom_name='list_to_tuple', function_args={'conversion_finder': conversion_finder})]
1005799
public function getCollection()
    {
        if (! isset($this->collection)) {
            return str_replace(
                '\\', '', Str::snake(Str::plural(class_basename($this)))
            );
        }

        return $this->collection;
    }
669588
protected function loadConverters()
    {
        foreach ($this->projection as $name => $type) {
            if ($this->projection->isArray($name)) {
                $this->converters[$name] = $this
                    ->session
                    ->getClientUsingPooler('converter', 'array')
                    ->getConverter()
                    ;
            } else {
                $this->converters[$name] = $this
                    ->session
                    ->getClientUsingPooler('converter', $type)
                    ->getConverter()
                    ;
            }

            $this->field_types[$name] = $type;
        }

        return $this;
    }
971683
public function getHeaderCollection()
    {
        if ($this->_headerCollection === null) {
            $headerCollection = new HeaderCollection();
            $headerCollection->fromArray($this->defaultHeaders());
            $this->_headerCollection = $headerCollection;
        }
        return $this->_headerCollection;
    }
756408
private function geometryCollection()
    {
        $values = array();
        $count  = $this->readCount();

        for ($i = 0; $i < $count; $i++) {
            $this->readByteOrder();

            $type     = $this->readType();
            $typeName = $this->getTypeName($type);

            $values[] = array(
                'type'  => $typeName,
                'value' => $this->$typeName()
            );
        }

        return $values;
    }
742151
public static function genericServices()
    {
        if (self::$generic_services !== null) {
            return self::$generic_services;
        }

        $readCallback = function (\Protobuf\ReadContext $context, $wire) {
            $reader = $context->getReader();
            $length = $context->getLength();
            $stream = $context->getStream();

            \Protobuf\WireFormat::assertWireType($wire, 8);

            $value = $reader->readBool($stream);

            return $value;
        };

        $writeCallback = function (\Protobuf\WriteContext $context, $value) {
            $stream      = $context->getStream();
            $writer      = $context->getWriter();
            $sizeContext = $context->getComputeSizeContext();

            $writer->writeVarint($stream, 400024);
            $writer->writeBool($stream, $value);
        };

        $sizeCallback = function (\Protobuf\ComputeSizeContext $context, $value) {
            $calculator = $context->getSizeCalculator();
            $size       = 0;

            $size += 3;
            $size += 1;

            return $size;
        };

        return self::$generic_services = new \Protobuf\Extension\ExtensionField('\\google\\protobuf\\FileOptions', 'generic_services', 50003, $readCallback, $writeCallback, $sizeCallback, __METHOD__);
    }
558907
public function getTypemap()
    {
        $typemap = array();

        foreach ($this->converters as $converter) {
            $typemap[] = array(
                'type_name' => $converter->getTypeName(),
                'type_ns'   => $converter->getTypeNamespace(),
                'from_xml'  => function($input) use ($converter) {
                    return $converter->convertXmlToPhp($input);
                },
                'to_xml'    => function($input) use ($converter) {
                    return $converter->convertPhpToXml($input);
                },
            );
        }

        return $typemap;
    }