Adds a node to the dependency graph.

@param string $className
193471
public function addNode(string $className): void
    {
        if (isset($this->nodes[$className])) {
            return;
        }

        $this->nodes[$className] = new DocumentGraphNode($className);
    }
730176
public function addClass($className){

        $formClass = $this->getClassName();
        if (is_string($formClass)){
            $formClass = explode(" ", $formClass);
        }
        $formClass[] = $className;

        $this->setFormClass($formClass);

        return $this;
    }
534808
public function add($interactorName, $className)
    {
        if (! $this->definitionExists($interactorName, $className)) {
            $this->validate($interactorName, $className);
            $this->set($interactorName, $className);
        }
    }
1230021
public function loadClass($className)
    {
        if (null === $this->_namespace || $this->_namespace.$this->_namespaceSeparator === substr($className, 0, strlen($this->_namespace.$this->_namespaceSeparator))) {
            $fileName = '';
            $namespace = '';
            if (false !== ($lastNsPos = strripos($className, $this->_namespaceSeparator))) {
                $namespace = substr($className, 0, $lastNsPos);
                $className = substr($className, $lastNsPos + 1);
                $fileName = str_replace($this->_namespaceSeparator, DIRECTORY_SEPARATOR, $namespace) . DIRECTORY_SEPARATOR;
            }
            $fileName .= str_replace('_', DIRECTORY_SEPARATOR, $className) . $this->_fileExtension;
            $filePath = ($this->_includePath !== null ? $this->_includePath . DIRECTORY_SEPARATOR : '') . $fileName;

            if (file_exists($filePath)) {
                require $filePath;
            }
        }
    }
1013081
final protected function assertClassIsAbstract(string $className): void
    {
        $this->assertClassExists($className);

        $reflection = new \ReflectionClass($className);

        self::assertTrue($reflection->isAbstract(), \sprintf(
            'Failed asserting that class "%s" is abstract.',
            $className
        ));
    }
604630
public function addClass( $className, $parameters = array() )
	{
		$object	= Alg_Object_Factory::createObject( $className, $parameters );
		$this->addObject( $object );
	}
809582
public static function load($className)
    {
        $namespace = __NAMESPACE__ . '\\';
        $length    = strlen($namespace);

        //        if (substr($className, 0, $length) !== $namespace) {
        if (0 !== strpos($className, $namespace)) {
            return;
        }

        // init() must have been called before
        assert(self::$libDir !== null);

        require self::$libDir . substr($className, $length) . self::EXTENSION;
    }
1077566
private function addNode(NodeInterface $node)
    {
        $this->nodeIndex++;
        $this->graph['nodes'][] = $node->toArray();

        return $this->nodeIndex;
    }
1150935
public function apply(AbstractNode $node): void
    {
        if (!$this->isPlugin($node)) {
            return;
        }

        $className = $node->getName();

        if (!$this->isSuffixValid($className)) {
            $this->addViolation($node, [$node->getName()]);
        }
    }
903002
public function addAlias(string $name, string $className)
    {
        $this->aliases[$name] = $className;
        return $this;
    }
99453
public function addClass($classname)
    {
        $classArr = $this->getClassArray();
        $classArr[] = $classname;
        return $this->setClassArray($classArr);
    }
49382
private function updateNodes($classname)
    {
        $this->output->writeln(sprintf('<info>Updating nested data for %s.</info>', $classname));

        if (true === $this->skipNodesUpdate) {
            $this->output->writeln(' - <comment>Skipped</comment> (option --skip-nodes-update set)');
            return $this;
        }

        $sites = $this->em->getRepository('BackBee\Site\Site')->findAll();
        if (0 === count($sites)) {
            $this->output->writeln(' - None site found - <comment>Skipped</comment>');
            return $this;
        }

        $progress = $this->getHelperSet()->get('progress');
        $progress->start($this->output, $this->countNodes($classname));

        $this->em->getConnection()->executeUpdate('SET FOREIGN_KEY_CHECKS=0');
        foreach ($sites as $site) {
            foreach ($this->getPageRoot($site, $classname) as $root_uid) {
                $this->updateTreeNatively($root_uid, $classname);
            }
        }
        $this->em->getConnection()->executeUpdate('SET FOREIGN_KEY_CHECKS=1');

        $progress->finish();

        return $this;
    }
10939
public function bindClassToRule ($className, $identifier)
		{
			if (! isset($this->rules[$identifier])) {
				throw new Dependency('Class ' . $className . ' set into invalid rule ' . $identifier);
			}

			$this->classIndex->setClassToRule($identifier, $className);

			return $this;
		}
3934
public function addChild(TreeNodeInterface $node): void
    {
        $this->children[] = $node;
        $this->isLeaf = false;
    }
229501
public function addNode($hash, $node)
    {
        $vertex = new stdClass();

        $vertex->hash           = $hash;
        $vertex->state          = self::NOT_VISITED;
        $vertex->value          = $node;
        $vertex->dependencyList = [];

        $this->nodeList[$hash] = $vertex;
    }
1212843
public function add($className)
    {
        if (!is_string($className)) {
            throw new InvalidArgumentException(sprintf('%s expects parameter 1 to be string, %s given', __METHOD__, (is_object($className) ? get_class($className) : gettype($className))));
        }

        $this->parseClassAttribute();

        if (in_array($className, $this->classes, true)) {
            return $this;
        }

        $this->classes[] = $className;

        $this->updateClassAttribute();

        return $this;
    }
130124
public static function addPropertyAnnotations($className, $propertyName, ...$annotations)
    {
        if(isset(static::$annotations[$className]['Properties'][$propertyName]))
        {
            static::$annotations[$className]['Properties'][$propertyName] = array_merge(static::$annotations[$className]['Properties'][$propertyName], $annotations);
        }
        else
        {
            static::$annotations[$className]['Properties'][$propertyName] = $annotations;
        }
        foreach($annotations as $annotation)
        {
            static::$annotationRelation[get_class($annotation)]['Property'][] = [
                'type'      =>  'Property',
                'class'     =>  $className,
                'property'  =>  $propertyName,
                'annotation'=>  $annotation,
            ];
        }
    }