Checks if the decorated object or one of it's mixin's inherits from a class.

@param   string|object $class  The class to check
@return  boolean  Returns TRUE if the object inherits from the class
436425
public function inherits($class)
    {
        $delegate = $this->getDelegate();

        if ($delegate instanceof ObjectMixable) {
            $result = $delegate->inherits($class);
        } else {
            $result = $delegate instanceof $class;
        }

        return $result;
    }
409555
protected function isArgumentEntityTransfer(AbstractASTClassOrInterface $class): bool
    {
        if ($class->getNamespaceName() !== static::NAMESPACE_TRANSFERS) {
            return false;
        }

        if (!preg_match(static::PATTERN_SUFFIX_ENTITY_TRANSFER, $class->getName())) {
            return false;
        }

        return true;
    }
1253394
public function inherits($class)
    {
        $result = false;
        $object = $this->getObject();

        if ($object instanceof AnObject) {
            $result = $object->inherits($class);
        } else {
            $result = $object instanceof $class;
        }

        return $result;
    }
1147945
public function hasClass($class) {
    if (isset($this->storage['class']) && $this->storage['class'] instanceof AttributeArray) {
      return in_array($class, $this->storage['class']->value());
    }
    else {
      return FALSE;
    }
  }
982808
public function loadClass(string $class): bool
    {
        $arrayClass = \explode('\\', $class);

        $arrayPrefix = [];

        while (\count($arrayClass)) {
            $arrayPrefix[] = \array_shift($arrayClass);

            $prefix = \implode('\\', $arrayPrefix);
            $relativeClass = \implode('\\', $arrayClass);

            // try to load a mapped file for the prefix and relative class
            if ($this->loadMappedFile($prefix, $relativeClass)) {
                return true;
            }
        }

        // never found a mapped file
        return false;
    }
203065
public function isSingleton(string $class): bool
	{
		$class = $this->resolveAlias($class);

		return isset($this->instances[$class]) || (isset($this->hints[$class]) && $this->hints[$class]['singleton'] === true);
	}
1201524
public function getParent($class)
    {
        $classId = $this->getClassId($class);
        if (!isset($classId)) {
            return false;
        }
        $parentClassId = $this->extends[$classId];
        return isset($parentClassId) ? $this->classes[$parentClassId[0]] : null;
    }
967703
public function supportsClass($class)
    {
        if($class)
        {
            $classNameArray = explode('\\', $class);
            $className = $classNameArray[ count($classNameArray)-1 ];

            if( in_array($className, array('User', 'AdminVoter')) )
            {
                return true;
            }
        }

        return false;
    }
625573
public function equals($object): bool
    {
        if (get_class($this) === get_class($object)) {
            $props = Collection::collect((new \ReflectionObject($this))->getProperties());

            return $props
                ->filter(function ($prop) use ($object) {
                    /** @var \ReflectionProperty $prop */
                    $prop->setAccessible(true);

                    return (string)$prop->getValue($object) === (string)$prop->getValue($this);
                })
                ->count() === $props->count()
            ;
        }

        return false;
    }
1074385
public static function hasHandlers($class, string $name): bool
    {
        if (
            empty(static::$_eventWildcards)
            && empty(static::$_events[$name])
        ) {
            return false;
        }
        $class = is_object($class)
            ? get_class($class)
            : ltrim($class, '\\');
        $classes = array_merge(
            [$class],
            class_parents($class, true),
            class_implements($class, true)
        );
        foreach ($classes as $class) {
            if (!empty(static::$_events[$name][$class])) {
                return true;
            }
        }
        foreach (static::$_eventWildcards as
            $nameWildcard => $classHandlers) {
            if (!StringHelper::matchWildcard($nameWildcard, $name)) {
                continue;
            }
            foreach ($classHandlers as $classWildcard => $handlers) {
                if (empty($handlers)) {
                    continue;
                }
                foreach ($classes as $class) {
                    if (!StringHelper::matchWildcard($classWildcard, $class)) {
                        return true;
                    }
                }
            }
        }
        return false;
    }
200354
public function hasClass($class)
    {
        $classes = explode(' ', strtolower($this->extraClass()));
        return in_array(strtolower(trim($class)), $classes);
    }
184111
private function loadCachedClass($class)
    {
        $result = false;

        if (isset($this->cache[$class])) {
            $result = include $this->cache[$class];

            if ($result === false) {
                unset($this->cache[$class]);
                $this->saveCache();
            }
        }

        return $result !== false;
    }
117982
private function doResolveClass($class)
    {
        foreach ($this->map as $mapClass => $value) {
            if (!$value) {
                continue;
            }

            if ($class === $mapClass || is_subclass_of($class, $mapClass)) {
                return $value;
            }
        }

        return false;
    }
728003
public static function isIgnoringTouch($class = null)
    {
        $class = $class ?: static::class;

        foreach (static::$ignoreOnTouch as $ignoredClass) {
            if ($class === $ignoredClass || is_subclass_of($class, $ignoredClass)) {
                return true;
            }
        }

        return false;
    }
537492
public static function is_subclass_of($class, $of)
    {
        $ancestry = isset(self::$ancestry[$class]) ? self::$ancestry[$class] : (self::$ancestry[$class] = ClassInfo::ancestry($class));
        return is_array($of) ? (bool)array_intersect($of, $ancestry) : array_key_exists($of, $ancestry);
    }
422429
public function instance_of($object, $class){
	    if(is_object($object)) return $object instanceof $class;
	    if(is_string($object)){
	        if(is_object($class)) $class=get_class($class);
	
	        if(class_exists($class)) return is_subclass_of($object, $class) || $object==$class;
	        if(interface_exists($class)) {
	            $reflect = new ReflectionClass($object);
	            return !$reflect->implementsInterface($class);
	        }
	
	    }
	    return false;
	}
1283888
public function hasClass($className)
    {
        foreach ($this->meta['classes'] as $classInMeta) {
            if ($classInMeta === $className) {
                return true;
            }
        }

        return false;
    }