Get the type if there is only one option left.

@return string|null
503083
protected function conclude(): ?string
    {
        $types = array_values($this->types);

        // Reset
        $this->types = [];
        $this->value = null;

        if (count($types) < 2) {
            return reset($types) ?: null;
        }

        if (
            count($types) === 2 &&
            (is_a($types[0], \Traversable::class, true) xor is_a($types[1], \Traversable::class, true))
        ) {
            $args = is_a($types[0], \Traversable::class, true) ? $types : array_reverse($types);
            return vsprintf('%s|%s[]', $args);
        }

        return null;
    }
1324655
public function getType()
    {
        if ($this->entity->getType()) {
            return new Type($this->entity->getType(), $this->locale);
        }

        return null;
    }
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;
    }
664134
public function getType() {
	    if (!array_key_exists('type', $this->configs)
            || empty($this->configs['type'])) {
	        return self::MYSQL;
        }
        return strtolower($this->configs['type']);
    }
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";
  }
845303
protected function findType()
    {
        $env = $this->input->getParameterOption(['--env', '-e']);
        return !empty($env) ? $env : parent::findType();
    }
947366
function get_type()
    {
        if ($this->subkeys[0]->has_private)
            return enigma_key::TYPE_KEYPAIR;
        else if (!empty($this->subkeys[0]))
            return enigma_key::TYPE_PUBLIC;

        return enigma_key::TYPE_UNKNOWN;
    }
1346377
public function getActCatType()
    {
        $sType = false;
        $aData = \OxidEsales\Eshop\Core\Registry::getConfig()->getRequestParameter("aSeoData");
        if ($aData && isset($aData["oxparams"])) {
            $oStr = getStr();
            $iEndPos = $oStr->strpos($aData["oxparams"], "#");
            $sType = $oStr->substr($aData["oxparams"], 0, $iEndPos);
        } elseif ($aList = $this->getSelectionList()) {
            reset($aList);
            $sType = key($aList);
        }

        return $sType;
    }
768623
private function getType(): array
    {
        if (!$this->type || $this->is('customize_preview')) {
            $this->type = parent::type();
        }

        return $this->type;
    }
968680
public function getTypeFromValue($value = null)
    {
        $value = ($value === null ? $this->value : $value);
        return array_search($value, self::$typeList);
    }
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';
  }
140144
public function getType() {
		if ($this->moufManager->getCode($this->getIdentifierName())===null) {
			return self::TYPE_DECLARATIVE;
		} else {
			return self::TYPE_PHP;
		}
	}
549704
public function getRequestedPostType()
    {
        if (!is_a($this->query, 'WP_Query')) {
            return null;
        }

        if (isset($this->query->query) && isset($this->query->query['post_type'])) {
            return $this->data['post_type'] = $this->query->query['post_type'];
        } else {
            return $this->data['post_type'] = null;
        }
    }
189026
public function getType()
    {
        if (isset($this->result[0]['type'])) {
            $error = $this->result[0]['type'];
            if (is_string($error)) {
                return $error;
            }
        }

        return 'NewscoopApiException';
    }
394340
public static function getType() : int
    {
        // Return the cached result if it's already available.
        if (null !== static::$type) {
            return static::$type;
        }

        $os = strtolower(php_uname("s"));

        // Check in order of likeliness.
        if (false !== strpos($os, 'unix')) {
            return static::$type = self::TYPE_UNIX;
        }

        if (0 === strpos($os, 'win')) {
            return static::$type = self::TYPE_WINDOWS;
        }

        if (false !== strpos($os, 'bsd')) {
            return static::$type = self::TYPE_BSD;
        }

        if (false !== strpos($os, 'darwin')) {
            return static::$type = self::TYPE_DARWIN;
        }

        if (false !== strpos($os, 'cygwin')) {
            return static::$type = self::TYPE_CYGWIN;
        }

        // Use the default otherwise.
        return static::$type = self::TYPE_UNIX;
    }
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;
    }
1120083
public function getType() : ?string
    {
        if (null === $this->type) {
            $success = null;

            try {
                $type = $this->getItem('browscap.type', false, $success);
            } catch (InvalidArgumentException $e) {
                $this->logger->error(new \InvalidArgumentException('an error occured while reading the data type from the cache', 0, $e));
                $type = null;
            }

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

        return $this->type;
    }