Returns the type as declared in the doc.
@return string
328381
public function getType(): string
    {
        $type = $this->parameter->type->__toString();
        $strType = Type::toRootNamespace($type);
        if ($strType !== 'mixed' && $strType !== 'resource' && $this->phpStanFunction !== null) {
            $phpStanParameter = $this->phpStanFunction->getParameter($this->getParameter());
            if ($phpStanParameter) {
                // Let's make the parameter nullable if it is by reference and is used only for writing.
                if ($phpStanParameter->isWriteOnly()) {
                    $strType = '?'.$strType;
                }
            }
        }
        return $strType;
    }
701502
public function getPKType() {
        if ($this->_pktype === null) {
            if ($this->_pk === null) {
                $this->getPK();
            }
            $this->_pktype= $this->xpdo->getPKType($this->_class);
        }
        return $this->_pktype;
    }
418935
public function getTypes()
    {
        if (!$this->columns && $this->length()) {
            foreach ($this->getColumns() as $col) {
                $this->types[$col] = 'string';
            }
        }

        return $this->types;
    }
921347
public function getTypeNice()
    {
        $description = $this->getDescription();
        $desc = ($description) ? ' <span class="element__note"> &mdash; ' . $description . '</span>' : '';

        return DBField::create_field(
            'HTMLVarchar',
            $this->getType() . $desc
        );
    }
640261
public function getResultingType() : \Dms\Core\Persistence\Db\Schema\Type\Type
    {
        return Integer::normal();
    }
825328
public function getXmlType()
	{
		if ( ! property_exists( $this->domNode, "schemaType" ) )
		{
			$effectiveNode = $this->domNode->nodeType == XML_TEXT_NODE ? $this->domNode->parentNode : $this->domNode;
			$this->domNode->schemaType = DOMSchemaType::getSchemaType( $effectiveNode );
		}
		return $this->domNode->schemaType;
	}
336805
public function type()
    {
        $lang = $this->lang();
        $html = [
            '<!doctype html>',
            '<!--[if lt IE 7]><html class="no-js lt-ie9 lt-ie8 lt-ie7 ie6" '
            . 'lang="' . $lang . '" dir="' . $this->dir . '"> <![endif]-->',
            '<!--[if IE 7]><html class="no-js lt-ie9 lt-ie8 ie7" '
            . 'lang="' . $lang . '" dir="' . $this->dir . '"> <![endif]-->',
            '<!--[if IE 8]><html class="no-js lt-ie9 ie8" '
            . 'lang="' . $lang . '" dir="' . $this->dir . '"> <![endif]-->',
            '<!--[if gt IE 8]><!--><html class="no-js" xmlns="http://www.w3.org/1999/xhtml" '
            . 'lang="' . $lang . '" dir="' . $this->dir . '" '
            . 'prefix="og: http://ogp.me/ns#" '
            . '> <!--<![endif]-->',
        ];
        return implode($this->eol, $html) . $this->eol;
    }
533303
public function getDocTypes() {
    // No type specified means type is mixed.
    $types = ['mixed'];
    // Use types from the doc comment if available.
    $doc_comment = $this->getFunction()->getDocComment();
    if (!$doc_comment) {
      return $types;
    }
    $param_tag = $doc_comment->getParameter($this->getName());
    if (!$param_tag) {
      return $types;
    }
    $types = Types::normalize($param_tag->getTypes());
    if (empty($types)) {
      $types[] = 'mixed';
    }
    return $types;
  }
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;
    }
141230
public function getBestType(): string
    {
        // Get the type from PhpStan database first, then from the php doc.
        if ($this->phpStanFunction !== null) {
            $phpStanParameter = $this->phpStanFunction->getParameter($this->getParameter());
            if ($phpStanParameter) {
                try {
                    return $phpStanParameter->getType();
                } catch (EmptyTypeException $e) {
                    // If the type is empty in PHPStan, let's fallback to documentation.
                    return $this->getType();
                }
            }
        }
        return $this->getType();
    }
22041
public function getHeaderPrototype()
    {
        if ($this->headerPrototype === NULL) {
            $this->headerPrototype = \Nette\Utils\Html::el('th')
                ->setClass(['column', 'grid-header-' . $this->getName()]);
        }

        if ($this->isSortable() && $this->getSort()) {
            $this->headerPrototype->class[] = $this->getSort() == self::ORDER_DESC
                ? 'desc'
                : 'asc';
        }

        return $this->headerPrototype;
    }
84870
function getGroupType()
    {
        $this->_createElementsIfNotExist();
        $prevType = '';
        foreach (array_keys($this->_elements) as $key) {
            $type = $this->_elements[$key]->getType();
            if ($type != $prevType && $prevType != '') {
                return 'mixed';
            }
            $prevType = $type;
        }
        return $type;
    }
470661
public function getType()
    {
        $type = null;
        if (($parent = $this->getParent()) instanceof ElementHandler && $parent->hasAttribute(self::ATTRIBUTE_TYPE)) {
            $type = $parent->getAttribute(self::ATTRIBUTE_TYPE)->getValue(false, false);
        }
        return $type;
    }
281719
public function getType()
    {
        if($this->_type == null) {
            $this->_type = parse_url($this->_path, PHP_URL_HOST);
        }

        return $this->_type;
    }
158168
public function getMediaType()
    {
        if ($ext = $this->getExtension()) {
            if (isset($this->mediaTypeExtensions[$ext])) {
                return $this->mediaTypeExtensions[$ext];
            }
        }

        return parent::getMediaType();
    }
612640
public function getActualEditorType() {
		if ($this->EditorType && $this->EditorType != 'Inherit') {
			return $this->EditorType;
		}

		$parent = $this->getParent();
		$editorType = 'Wiki';
		while ($parent != null && $parent instanceof WikiPage) {
			if ($parent->EditorType && $parent->EditorType != 'Inherit') {
				return $parent->EditorType;
			}
			$parent = $parent->getParent();
		}

		return 'Wiki';
	}
628260
public function getTypeText()
    {
        switch ($this->type) {
            case 'follow_user':
                return Yii::t('notification', 'follow on you');
                break;
            case 'answer_question':
                return Yii::t('notification', 'answered the question');
                break;
            case 'follow_question':
                return Yii::t('notification', 'is concerned about the problem');
                break;
            case 'comment_question':
                return Yii::t('notification', 'commented on the question');
                break;
            case 'invite_answer':
                return Yii::t('notification', 'invited you to answer');
                break;
            case 'adopt_answer':
                return Yii::t('notification', 'accepted your answer');
                break;
            default:
                return null;
                break;
        }
    }