Gets the type of the parameter.

@return mixed Blank when none, 'Closure', 'callable', 'array', or class name.
514333
public function getTypeHint()
    {
        $typeHint = $this->node->type;
        if ($typeHint instanceof Node\Name) {
            $typeHint = (string) $typeHint;
        }
        return $typeHint;
    }
1354440
public function getTypes()
    {
        $schema = StaticSchema::inst();
        $tree = array_merge(
            [$this->rootClass],
            $schema->getDescendants($this->rootClass)
        );

        return array_map(function ($class) use ($tree, $schema) {
            return $schema->typeNameForDataObject($class);
        }, $tree);
    }
845303
protected function findType()
    {
        $env = $this->input->getParameterOption(['--env', '-e']);
        return !empty($env) ? $env : parent::findType();
    }
910529
public function getType(): string
    {
        if (null === $this->type) {
            $success = true;

            $type = $this->getItem('browscap.type', false, $success);

            if (null !== $type && $success) {
                $this->type = $type;
            }
        }

        return $this->type;
    }
940093
public function getRawDataType()
	{
		if ( !isset($this->dataType) ) {
			/* @var $annotations VarAnnotation[] */
			$annotations = $this->annotationManager->getPropertyAnnotations($this, null, '@var');

			if ( $annotations && ($annotations[0] instanceof VarAnnotation) ) {
				$this->dataType = $annotations[0]->type;
			}
			else {
				$this->dataType = '';
			}
		}

		return $this->dataType;
	}
962904
public function getType(): DataType
    {
        if (is_object($this->variable)) {
            $typeName = get_class($this->variable);

            return DataType::make($typeName);
        }

        $typeName = gettype($this->variable);

        return DataType::make($typeName);
    }
687161
public function getType() {
    if (isset($this->result['error'])) {
      $message = $this->result['error'];
      if (is_string($message)) {
        // OAuth 2.0 Draft 10 style
        return $message;
      }
    }
    return 'Exception';
  }
43272
private function getClass()
    {
        $parts = $this->explodeCallable($this->handler);

        if ($this->isStaticMethod()) {
            return $parts[0];
        }

        return get_class($parts[0]);
    }
210188
public function type(): string
    {
        if (is_string($this->value)) {

            return $this->string($this->value);

        }

        if (is_array($this->value)) {

            return $this->array($this->value);

        }

        if (is_object($this->value)) {

            return $this->object($this->value);

        }

        return gettype($this->value);
    }
1293627
public function getDataType()
    {
        if (!is_array($this->dataType)) {
            $dataType = get_class($this->dataType);

            return new $dataType();
        }

        return $this->dataType;
    }
905839
public static function getType()
    {
        $clsInfo = explode('\\', get_called_class());
        $namespaceParts = array_slice($clsInfo, 0, -1);
        // convention: AdminType classes are placed into the "<bundle>\Element\Type" namespace
        $namespaceParts[] = "Type";
        $bareClassName = implode('', array_slice($clsInfo, -1));
        // convention: AdminType class name is the same as the element class name suffixed with AdminType
        return implode('\\', $namespaceParts) . '\\' . $bareClassName . 'AdminType';
    }
1103516
public function getType()
    {
        if($this->_type == null)
        {
            if($path = $this->getPath())
            {
                if(!$this->_type = @filetype($path)) {
                    $this->_type = self::TYPE_UNKNOWN;
                }
            }
        }

        return $this->_type;
    }
85853
public function getDefault()
    {
        if ($this->reflection->isDefaultValueAvailable()
            and $default = $this->reflection->getDefaultValue()
        ) {
            if (is_scalar($default)) {
                return $default;
            } else {
                return $this->tostring($default);
            }
        }
        if ($this->reflection->isArray()) {
            return '[]';
        }
        if ($this->isPassedByReference()) {
            return 'null';
        } elseif ($this->reflection->getClass()) {
            // This gets injected as a new instance.
            return null;
        }
        $type = $this->getType();
        if (!$type) {
            $type = $this->extractParameterData();
        }
        // Guesstimated values:
        switch ($type) {
            case 'int': case 'integer': case 'float':
                return 0;
            case 'string':
                return "''";
            case 'array':
                return '[]';
        }
        return null;
    }
1012702
public function getType()
    {
        $name = get_class($this);
        $name = explode('\\', $name);
        $name = $name[count($name) - 2];

        return $name;
    }
294198
public function getRespondType()
    {
        $_respondType = $this->_respondType;
        if($respondType = $this->getConfig('respondType')) {
            $_respondType  =  $respondType;
        }

        return $_respondType;
    }
839140
protected function getType()
  {
    if($this->currObj instanceof TeamSpeak3_Node_Server)
    {
      return "server";
    }
    elseif($this->currObj instanceof TeamSpeak3_Node_Channel)
    {
      return "channel";
    }
    elseif($this->currObj instanceof TeamSpeak3_Node_Client)
    {
      return "client";
    }
    elseif($this->currObj instanceof TeamSpeak3_Node_Servergroup || $this->currObj instanceof TeamSpeak3_Node_Channelgroup)
    {
      return "group";
    }

    return "host";
  }
123802
public function getType() : int
    {
        $query = 'SELECT type_id FROM info LIMIT 1';

        $typeId = Type::UNKNOWN;
        foreach ($this->getAdapter()->query($query) as $row) {
            $typeId = (int)$row['type_id'];
        }

        return $typeId;
    }