Returns the field type in a serializer-understandable way..

@return string Type
964694
public function getTypeSerializer()
    {
        $type = 'array<'.$this->element->getTypeSerializer().'>';

        // if we have a x-dynamic-key field, serializer type must be changed
        if ($this->element instanceof JsonDefinitionField && !empty($this->element->getXDynamicKey())) {
            $type = 'array<string, '.$this->element->getTypeSerializer().'>';
        }

        return $type;
    }
1055462
public function getFieldTypeService()
    {
        if (null === $this->fieldTypeService) {
            $this->fieldTypeService = new FieldTypeService($this->fieldTypes);
        }

        return $this->fieldTypeService;
    }
225816
public function getSerializer() {
		if(!$this->serializer)
			$this->serializer = new \Asgard\Entity\Serializer;
		return $this->serializer;
	}
3514
public function getFieldsType() {
        $data = $this->getAllColumn();
        $args = [];
        foreach ($data as $field) {
            $args[$field['Field']] = $this->isNumeric($field['Type']);
        }
        return $args;
    }
1370293
public function serializer($type = null)
    {
        $type = $type ?? 'php';

        if (isset($this->serializers[$type])) {
            return $this->serializers[$type];
        }

        return $this->serializers[$type] = $this->resolve($type);
    }
13536
public function getSerializer()
    {
        if ($this->serializer) {
            return $this->serializer;
        }

        $serializerName = $this->getSerializerName();
        /** @var Serializer $serializer */
        $serializer = $this->getSerializerManager()->get($serializerName);
        $this->serializer = $serializer;

        return $this->serializer;
    }
904933
public function getReturnType(): Type
    {
        if (! isset($this->returnType)) {
            $this->returnType = app(DefinitionNodeConverter::class)->toType(
                $this->field->type
            );
        }

        return $this->returnType;
    }
508777
public function getSerializationType()
    {
        switch ($this->association) {
            case self::ASSOCIATION_TYPE_EMBED_ONE:
            case self::ASSOCIATION_TYPE_EMBED_MANY:
                return TypeFactory::getType(Type::MAP);
            case self::ASSOCIATION_TYPE_REFERENCE_ONE:
            case self::ASSOCIATION_TYPE_REFERENCE_MANY:
                return $this->getReferenceSerializationType();
        }

        throw new \BadMethodCallException;
    }
804727
private static function getSerializer(): Serializer
    {
        if (static::$serializer === null) {
            $extractor          = new PropertyInfoExtractor([], [new PhpDocExtractor(), new ReflectionExtractor()]);
            static::$serializer = new Serializer(
                [new ObjectNormalizer(null, null, null, $extractor)],
                [new JsonEncoder()]
            );
        }
        return static::$serializer;
    }
400698
def get_resource_type_from_included_serializer(self):
        
        field_name = self.field_name or self.parent.field_name
        parent = self.get_parent_serializer()

        if parent is not None:
            # accept both singular and plural versions of field_name
            field_names = [
                inflection.singularize(field_name),
                inflection.pluralize(field_name)
            ]
            includes = get_included_serializers(parent)
            for field in field_names:
                if field in includes.keys():
                    return get_resource_type_from_serializer(includes[field])

        return None
632682
private function getFieldName()
    {
        $environment   = $this->getEnvironment();
        $inputProvider = $environment->getInputProvider();

        $fieldName = $inputProvider->hasValue('name') ? $inputProvider->getValue('name') : null;
        if (null === $fieldName) {
            return $fieldName;
        }

        if (('select' !== $inputProvider->getParameter('act'))
            && ('edit' !== $inputProvider->getParameter('mode'))
        ) {
            return $fieldName;
        }

        $dataDefinition = $environment->getDataDefinition();
        $sessionStorage = $environment->getSessionStorage();

        $session = $sessionStorage->get($dataDefinition->getName() . '.' . $inputProvider->getParameter('select'));

        $originalPropertyName = null;
        foreach ($session['models'] as $modelId) {
            if (null !== $originalPropertyName) {
                break;
            }

            $propertyNamePrefix = \str_replace('::', '____', $modelId) . '_';
            if (0 !== strpos($fieldName, $propertyNamePrefix)) {
                continue;
            }

            $originalPropertyName = \substr($fieldName, \strlen($propertyNamePrefix));
        }

        if (!$originalPropertyName) {
            return $fieldName;
        }

        return $originalPropertyName;
    }
1348621
public function getEncType()
    {
        if ($this->encType) {
            return $this->encType;
        }

        if ($fields = $this->fields->dataFields()) {
            foreach ($fields as $field) {
                if ($field instanceof FileField) {
                    return self::ENC_TYPE_MULTIPART;
                }
            }
        }

        return self::ENC_TYPE_URLENCODED;
    }
927654
public function getFieldTypes()
    {
        // First make sure all items are correct type (call closures)
        foreach ($this->fieldTypes as $identifier => $value) {
            if (!$value instanceof SPIFieldTypeNameable) {
                $this->getFieldType($identifier);
            }
        }

        return $this->fieldTypes;
    }
834024
public function getMimeType()
	{
		$field	= $this->headers->getField( 'Content-Type' );
		$parts	= explode( ';', $field->getValue() );
		return $parts[0];
	}
1262281
protected function getFieldTypes() {
        if (!$this->_fieldTypes) {
            $this->_fieldTypes = new FieldTypeList($this->version, $this->solution['sid']);
        }

        return $this->_fieldTypes;
    }
995327
public function getFieldString()
    {
        $fieldString = "`" . $this->m_name . "` " . $this->m_type;
        
        if ($this->m_constraint != null)
        {
            $fieldString .= " (" . $this->m_constraint . ")";
        }
                
        if ($this->isAutoIncrementing())
        {
            $fieldString .= " AUTO_INCREMENT";
        }
        
        if ($this->m_default !== null)
        {
            $fieldString .= " DEFAULT " . $this->m_default;
        }
        
        if (!$this->m_allowNull)
        {
            $fieldString .= " NOT NULL";
        }
        
        return $fieldString;
    }
329472
public static Type getType(Field field) {
		if (null == field) {
			return null;
		}
		Type type = field.getGenericType();
		if (null == type) {
			type = field.getType();
		}
		return type;
	}