Explore each user classes found in the current namespace.

@param Node\Stmt\Class_ $class The current user class explored

@return void
327757
protected function visitClass(Node\Stmt\Class_ $class)
    {
        $this->metrics['classes']++;
        $this->metrics['llocClasses'] += $this->llocClasses;
    }
21242
void readInnerClasses(ClassSymbol c) {
        int n = nextChar();
        for (int i = 0; i < n; i++) {
            nextChar(); // skip inner class symbol
            ClassSymbol outer = readClassSymbol(nextChar());
            Name name = readName(nextChar());
            if (name == null) name = names.empty;
            long flags = adjustClassFlags(nextChar());
            if (outer != null) { // we have a member class
                if (name == names.empty)
                    name = names.one;
                ClassSymbol member = enterClass(name, outer);
                if ((flags & STATIC) == 0) {
                    ((ClassType)member.type).setEnclosingType(outer.type);
                    if (member.erasure_field != null)
                        ((ClassType)member.erasure_field).setEnclosingType(types.erasure(outer.type));
                }
                if (c == outer) {
                    member.flags_field = flags;
                    enterMember(c, member);
                }
            }
        }
    }
615292
public function setAuthClass($class)
  {
    $prev = $this->configuration['auth_class'];
    if (!isset($this->configuration['classes'][$class]) &&
        isset($this->configuration['classes'][$prev])) {
      $this->configuration['classes'][$class] =
          $this->configuration['classes'][$prev];
    }
    $this->configuration['auth_class'] = $class;
  }
81970
private function findMostConcreteDefinition($class)
    {
        //This array holds the classes that were processed
        $visited = [];

        //One can specify an alias of an alias (or rather, override a class definition by an other)
        //so we have to traverse this structure
        while (isset($this->aliases[$class]) && is_string($this->aliases[$class])) {
            $class = $this->aliases[$class];
            if (isset($visited[$class])) {
                //If $class was already visited, we have a circular alias situation that can't be resolved
                throw new \RuntimeException("Circular aliases detected for class {$class}.");
            }
            $visited[$class] = true;
        }

        //At this point, $class is either the last alias (it is the most concrete class name registered)
        //or it is not a string. This can happen when a class has a Closure initializer.
        return $class;
    }
1320260
protected function define(ClassDefinition $class)
    {
        $class->property($this->name)->asString();

        $class->property($this->value)->asString();
    }
556474
private function initializeMethodNamesMap($class)
    {
        $this->serviceIdToMethodNameMap = array();
        $this->usedMethodNames = array();

        if ($reflectionClass = $this->container->getReflectionClass($class)) {
            foreach ($reflectionClass->getMethods() as $method) {
                $this->usedMethodNames[strtolower($method->getName())] = true;
            }
        }
    }
1341750
public void visitClass(ClassNode node) {
        // AIC are already done, doing them here again will lead to wrong scopes
        if (isAnonymous(node)) return;

        pushState();

        prepareVisit(node);

        super.visitClass(node);
        if (recurseInnerClasses) {
            Iterator<InnerClassNode> innerClasses = node.getInnerClasses();
            while (innerClasses.hasNext()) {
                visitClass(innerClasses.next());
            }
        }
        popState();
    }
709122
public static function initializeClass($class)
    {
        try
        {
            // Get a static method named 'initialize'. If not found,
            // ReflectionMethod() will throw a ReflectionException.
            $ref = new \ReflectionMethod($class, 'initialize');

            // The 'initialize' method is probably 'private'.
            // Make it accessible before calling 'invoke'.
            // Note that 'setAccessible' is not available
            // before PHP version 5.3.2.
            $ref->setAccessible(true);

            // Execute the 'initialize' method.
            $ref->invoke(null);
        }
        catch (Exception $e)
        {
        }
    }
1246676
public function autoLoad($class) {
        $lowerClass = strtolower($class);

        if (isset($this->classMap[$lowerClass])) {
            include($this->classMap[$lowerClass]);
        }
    }
830067
private function find_file( $class )
    {
        foreach ( $this->namespaces as $namespace => $dirs )
        {
            if ( $class === strstr( $class, $namespace ) ) 
            {
                foreach ( $dirs as $dir )
                {
                    return $this->apply_namespace_filters( $namespace, $class, $dir );
                }
            }
        }
    }
374038
public function setCacheClass($class)
  {
    $prev = $this->configuration['cache_class'];
    if (!isset($this->configuration['classes'][$class]) &&
        isset($this->configuration['classes'][$prev])) {
      $this->configuration['classes'][$class] =
          $this->configuration['classes'][$prev];
    }
    $this->configuration['cache_class'] = $class;
  }
532130
protected function processClassStatement(Class_ $statement, string $prefix, array $uses = []): void
    {
        $class = $statement;
        $fullClassName = $prefix . '\\' . (string)$class->name;

        $this->classes[$fullClassName] = [
            'file' => $this->file,
            'line' => $class->getAttribute('startLine'),
            'name' => $fullClassName,
            'docblock' => $this->getDocBlock($class, $uses),
        ];

        foreach ($statement->stmts as $method) {
            if (!($method instanceof ClassMethod)) {
                continue;
            }

            $this->processClassMethod($method, $fullClassName, $uses);
        }
    }
1079187
private function _isClassInList($class, $classes)
    {
        $items = explode(" ", trim($classes));
        if (count($items) > 0) {
            foreach ($items as $item) {
                if (strcasecmp($class, trim($item)) == 0) {
                    return true;
                }
            }
        }
        return false;
    }
224490
public function clear($class)
    {
        $concrete = $this->getAlias($class);
        unset($this->_aliases[$class]);

        unset($this->_definitions[$concrete], $this->_singletons[$concrete]);
    }
304071
public function containsClass($class)
    {
        $class = is_object($class) ? get_class($class) : $class;
        foreach ($this->candidates as $candidate) {
            if ($candidate instanceof $class) {
                return true;
            }
        }

        return false;
    }
324865
public function addClass($class) {
        $this->setVariable(self::VIEW_MODEL_CLASS, $this->addValue($this->getVariable(self::VIEW_MODEL_CLASS), $class));
    }
25848
protected function _findClasses($class_names)
    {
        if (!is_array($class_names)) {
            $class_names = array($class_names);
        }
        foreach ($class_names as $_cls) {
            if (true===class_exists($_cls)) {
                return $_cls;
            }
        }
        return false;
    }