Get whether a converter was used or not.

@param string|null $alias
@return bool
178590
public function getWasConverterUsed($alias = null)
    {
        if ($alias) {
            return isset($this->converterAliasUsed[$alias]) ? $this->converterAliasUsed[$alias] : false;
        } else {
            return $this->converterUsed;
        }
    }
817850
public function load($alias)
    {
        if (array_key_exists($alias, $this->aliases)) {
            return class_alias($this->aliases[$alias], $alias);
        }

        return false;
    }
1081760
public function getConfig($alias = null)
    {
        if ($alias === null) {
            return $this->_config;
        }

        return isset($this->_config[$alias]) ? $this->_config[$alias] : [];
    }
450361
def has_conversion(self, plugin):
        """"""
        plugin = kurt.plugin.Kurt.get_plugin(plugin)
        return plugin.name in self._plugins
964143
public function hasColumnAlias($alias)
    {
        return $this->hasAlias($alias) && $this->getExpression($this->getHash($alias)) instanceof Expr\Column;
    }
1331001
public static function getInstance($alias = null)
	{
		if('' === static::$driverName)
		{
			static::init();
		}
		if(null === $alias)
		{
			$alias = self::defaultAlias();
		}
		if (isset(self::$instances[static::$driverName][$alias]))
		{
			return self::$instances[static::$driverName][$alias];
		}
		else
		{
			$option = Config::get('@.APP_' . strtoupper(static::$driverName) . '.' . $alias);
			if(false === $option)
			{
				return null;
			}
			else
			{
				return self::create($option,$alias);
			}
		}
	}
88757
public function getType($alias)
    {
        if (array_key_exists($alias, $this->types)) {
            return $this->types[$alias];
        }

        return false;
    }
1271897
public function getFunctionByAlias($alias)
    {
        return $this->hasFunctionAlias($alias) ? $this->getExpression($this->getHash($alias)) : null;
    }
573365
public static function hasAlias(string $alias): bool
    {
        // empty OR not an alias
        if (!$alias || $alias[0] !== '@') {
            return false;
        }

        return isset(self::$aliases[$alias]);
    }
14493
protected function getAliasAndSuffix($alias = null)
    {
        $suffix = count($this->getParameters());
        $alias = $this->getFirstAlias($alias);

        return array($alias, $suffix);
    }
956989
public function resolve($alias): ?Type
    {
        if (null === $alias) {
            return null;
        }

        if (!isset($this->cache[$alias])) {
            $type = $this->string2Type($alias);
            $this->cache[$alias] = $type;
        }

        return $this->cache[$alias];
    }
145655
public function addUse(string $use, string $alias = null)
    {
        $this->repairUse($use);

        list($class, $namespace) = $this->extractClassNameFromUse($use);

        if ($namespace === $this->namespace) {
            return $class;
        }

        $found = array_key_exists($use, $this->uses) ? $this->uses[$use] : false;

        switch (true) {
            case $found === $alias : // already used, same alias (or no alias)
                break;
            case $found === null : // already used without alias but alias provided
                throw new DuplicateUseFirstWithoutAliasException($use, $alias);
            case $found === false : // never used
                $this->uses[$use] = ($alias !== $class) ? $alias : null;
                break;
            default : // already used with different alias
                throw new DuplicateUseWithAliasException($use, $alias, $found);
        }

        return $alias ?: $class;
    }
961226
public function toLdapFilter($alias = null)
    {
        if (is_null($alias) && !empty($this->aliases)) {
            $filter = $this->getLdapFilterForAliases();
        } else {
            $filter = $this->getLdapFilter($alias);
        }

        return $filter;
    }
255310
function isImageAliasValid( $alias )
    {
        $aliasName = $alias['name'];
        if ( isset( $this->AliasList[$aliasName] ) )
        {
            $aliasKey = $alias['alias_key'];
            $aliasInfo = $this->AliasList[$aliasName];
            $checkKey = $aliasInfo['alias_key'];
            $isValid = ( $aliasKey == $checkKey );
            if ( $isValid )
            {
                $aliasTimestamp = $alias['timestamp'];
                $isValid = $this->isImageTimestampValid( $aliasTimestamp );
            }
            return $isValid;
        }
        return false;
    }
1002142
public function resolveAlias(string $alias)
    {
        if (isset($this->aliases[$alias]))
            return $this->aliases[$alias];

        if (empty($this->parent_scope))
            return null;

        return $this->parent_scope->resolveAlias($alias);
    }
566520
public function isQueued(string $alias): bool
    {
        $query = $this->createQueryBuilder('c')
            ->where('c.alias = :alias')
            ->andWhere('c.ended is NULL')
            ->setParameter('alias', $alias)
            ->getQuery();

        try {
            $result = $query->setMaxResults(1)->getOneOrNullResult();
            if ($result) {
                return true;
            }
        } catch (NonUniqueResultException $e) {
            return false;
        }

        return false;
    }
1197777
public function getColumnByAlias($alias)
    {
        return $this->hasColumnAlias($alias) ? $this->getExpression($this->getHash($alias)) : null;
    }