Whether a mapping entry is defined for a given $qtiClassName.

@param string $qtiClassName A QTI class name.
@param string $ns
@return boolean Whether a mapping entry is defined.
352598
public function hasMappingEntry($qtiClassName, $ns = 'qtism')
    {
        $mapping = &$this->getMapping();

        return isset($mapping[$ns]) && isset($mapping[$ns][$qtiClassName]);
    }
1247086
public function isClassReflected($className)
    {
        if (!$this->initialized) {
            $this->initialize();
        }
        $className = $this->cleanClassName($className);

        return isset($this->classReflectionData[$className]);
    }
181491
public function hasMethod($methodName)
    {
        $methodNameLower = strtolower($methodName);
        foreach ($this->methods as $name => $method) {
            if ($methodNameLower == $name) {
                return true;
            }
        }

        $extendsClassDefinition = $this->getExtendsClassDefinition();
        if ($extendsClassDefinition instanceof ClassDefinitionRuntime) {
            try {
                $extendsClassDefinition = $this->compiler->getInternalClassDefinition(
                    $extendsClassDefinition->getName()
                );
            } catch (\ReflectionException $e) {
                // Do nothing
                return false;
            }
        }

        while ($extendsClassDefinition instanceof self) {
            if ($extendsClassDefinition->hasMethod($methodName)) {
                return true;
            }

            $extendsClassDefinition = $extendsClassDefinition->getExtendsClassDefinition();
        }

        return false;
    }
1051669
protected function findMappingFile($className)
    {
        $fileName = str_replace('\\', '.', $className) . $this->fileExtension;

        // Check whether file exists
        foreach ((array) $this->paths as $path) {
            if (file_exists($path . DIRECTORY_SEPARATOR . $fileName)) {
                return $path . DIRECTORY_SEPARATOR . $fileName;
            }
        }
        return false;

        //throw MappingException::mappingFileNotFound($className, $fileName);
    }
656605
public function isTransient($className)
    {
        $rc = new \ReflectionClass($className);

        if ($rc->isAbstract()) {
            return true;
        }

        $interfaces = class_implements($className);

        return !in_array('PandawanTechnology\Neo4jDataFixtures\Neo4jFixtureInterface', $interfaces);
    }
1231239
private final boolean classNeedsTransform(String className) {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.entry(tc, "classNeedsTransform : PUID = " + ivArchivePuId + ", class name = " + className); //d454146
        }

        boolean rtnVal = true;
        for (Pattern regex : transformExclusionPatterns) {
            if (regex.matcher(className).matches()) {
                rtnVal = false;
                break;
            }
        }
        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "classNeedsTransform : " + className
                        + (rtnVal ? " needs" : " does not need") + " transform.");
        return rtnVal;
    }
674468
public static function isClassAbstract($className)
    {
        if (!class_exists($className)) {
            return false;
        }

        $reflectionClass = new \ReflectionClass($className);

        return $reflectionClass->isAbstract();
    }
497714
public static function hasModel($shortName, $instaitiateOnTrue = false)
    {
        $models = static::models();
        if (isset($models[$shortName])) {
            if ($instaitiateOnTrue) {
                $className = $models[$shortName];
                return $className::model();
            } else {
                return true;
            }
        }
        return false;
    }
1363559
public function has($class) {
		if (isset($this->singletons[$class])) {
			return true;
		}

		if (isset($this->aliases[$class])) {
			$class = $this->aliases[$class];
		}

		try {
			$this->getReflectionClass($class);
		} catch (Exception $e) {
			return false;
		}

		return true;
	}
509790
public static function classExists($className, $namespace)
    {
        if (class_exists($className)) {
            return $className;
        }

        // add namespace
        $className = sprintf('%s%s', static::getFormatNamespace($namespace, true), $className);

        if (class_exists($className)) {
            return $className;
        }

        return false;
    }
424110
public function registerNamespace(PHPTAL_Namespace $ns)
    {
        $this->namespaces_by_uri[$ns->getNamespaceURI()] = $ns;
        $this->prefix_to_uri[$ns->getPrefix()] = $ns->getNamespaceURI();
        $prefix = strtolower($ns->getPrefix());
        foreach ($ns->getAttributes() as $name => $attribute) {
            $key = $prefix.':'.strtolower($name);
            $this->_dictionary[$key] = $attribute;
        }
    }
948845
public function isController(string $className) : bool
    {
        $refClass = new \ReflectionClass($className);


        foreach ($refClass->getMethods() as $refMethod) {
            $actionAnnotation = $this->annotationReader->getMethodAnnotation($refMethod, Action::class);
            if ($actionAnnotation) {
                return true;
            }
            $urlAnnotation = $this->annotationReader->getMethodAnnotation($refMethod, URL::class);
            if ($urlAnnotation) {
                return true;
            }
        }

        return false;
    }
1307397
protected boolean i_recordScannedClassName(String i_className) {
        boolean didPlaceClass = annotationTargets.i_placeClass(i_getClassSourceName(), i_className);
        if (!didPlaceClass) {
            return false;
        }

        boolean didAddClass = annotationTargets.i_addScannedClassName(i_className, getScanPolicy());
        return didAddClass;
    }
964699
public function hasInterfaceUsageByClass($className)
    {
        if (!isset($this->interfaceUsages[$className])) {
            return false;
        }

        return count($this->interfaceUsages[$className]) > 0;
    }
891922
public function validate( $variableSet, $nsMgr )
	{
		if ( $this->qnameExpressions )
		{
			foreach ( $this->qnameExpressions as $qnameExpression )
			{
				try
				{
					$xpath2Expression = XPath2Expression::Compile( $qnameExpression, $nsMgr );
					if ( parent::checkForCoverXFIFunctionUse( $qnameExpression, $xpath2Expression ) )
					{
						return false;
					}

					$this->qnameXPath2Expressions[] = $xpath2Expression;
				}
				catch ( XPath2Exception $ex )
				{
					\XBRL_Log::getInstance()->formula_validation( "Concept name filter", "Failed to compile qname expression",
						array(
							'qname expression' => $qnameExpression,
							'error' => $ex instanceof XPath2Exception ? ( $ex->ErrorCode == 'XPST0017' ? "xbrlve:noCustomFunctionSignature" : $ex->ErrorCode ) : get_class( $ex ),
							'reason' => $ex->getMessage()
						)
					);
				}
				catch ( \Exception $ex )
				{
					// BMS 2018-03-27 Test 21201 V-02 requires that this compile failure return xbrlve:noCustomFunctionSignature
					//				  because the custom function my-own:ending-balance does not exist
					\XBRL_Log::getInstance()->formula_validation( "Concept name filter", "Failed to compile qname expression",
						array(
							'qname expression' => $qnameExpression,
							'error' => $ex instanceof XPath2Exception ? ( $ex->ErrorCode == 'XPST0017' ? "err:XPST0017" : $ex->ErrorCode ) : get_class( $ex ),
							'reason' => $ex->getMessage()
						)
					);
				}
			}
		}

		return true;
	}
198992
public function isClassAbstract($className)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return isset($this->classReflectionData[$className][self::DATA_CLASS_ABSTRACT]);
    }
938535
public function hasClass($className)
    {
        if(strlen($className) < 1)
        {
            throw new HTMLTagException("Class name is empty");
        }

        if($this->hasAttribute("class"))
        {
            $classes = $this->getClasses();

            foreach(explode(" ",$classes) as $class) {
                if(strtolower($class) == strtolower($className)) {
                    return true;    // We found it.
                }
            }

        }

        return false;
    }