Register class footprint

@param $className
@param ClassFootprint $footprint

@return $this
194996
public function registerFootprint($className, ClassFootprint $footprint)
    {
        $this->_footprintRegistry->addFootprint($className, $footprint);
        return $this;
    }
201180
public function named(string $className): self
    {
        if ($this->isFinalized) {
            throw new FinalizedMockException();
        }

        if ('' !== $className) {
            if (
                !preg_match('/^' . static::SYMBOL_PATTERN . '$/S', $className)
            ) {
                throw new InvalidClassNameException($className);
            }
        }

        $this->className = $className;

        return $this;
    }
270575
public static function register($class, $priority = 0)
    {
        if (! in_array($class, self::$modules)) {
            $priority = str_pad($priority, 4, '0', STR_PAD_LEFT);
            $key = sprintf('%s:%s', $priority, $class);
            self::$modules[$key] = $class;
        }
    }
679756
public function isRegistered($entityClassName)
    {
        if ($entityClassName instanceof Entity) {
            $reflection = new \ReflectionClass($entityClassName); // @codeCoverageIgnore
            $entityClassName = $reflection->getName(); // @codeCoverageIgnore
        } // @codeCoverageIgnore

        return isset($this->entities[$entityClassName]);
    }
99453
public function addClass($classname)
    {
        $classArr = $this->getClassArray();
        $classArr[] = $classname;
        return $this->setClassArray($classArr);
    }
211152
public function registerAlias($alias, $className)
    {

        $this->_aliases[$alias] = $this->resolveClassName($className);

        return $this;
    }
431114
public static function create($className) {
        // The best logger configuration for the given class name
        $bestLoggerConfiguration = LoggerManager::findBestLoggerConfigurationForClass($className);

        // If no logger configuration was found for the given class name
        if (!isset($bestLoggerConfiguration)) {
            // Return an empty logger
            return new Logger($className);
        }

        // A logger configuration has been found for the given class name
        $logger = new Logger($className);
        $logger->_targetClassName = $bestLoggerConfiguration['class'];
        $logger->_level = LogLevel::createFromCode($bestLoggerConfiguration['level']);
        $logger->_setupWriters($bestLoggerConfiguration['writers']);

        return $logger;
    }
1271988
public static function registerClassAndSave($transformer, $classname) {
		self::start ();
		self::registerClass ( $transformer, $classname );
		self::store ();
	}
719474
public function register($cubeClassName, array &$definitions)
    {
        if (!isset($this->registered[$cubeClassName])) {
            $cube = new $cubeClassName;
            if (!$cube instanceof AbstractCube) {
                throw new CubeException($cubeClassName . ' is not an instance of ' . AbstractCube::class);
            }

            if ($cube->enabled) {
                $cube->registerDependencies($definitions);
                $this->registered[$cubeClassName] = $cube;
            }
        }
    }
330825
protected function setTilesClass($className) {
        if ($this->configured)                        throw new IllegalStateException('Configuration is frozen');
        if (!is_class($className))                    throw new StrutsConfigException('Class '.$className.' not found');
        if (!is_subclass_of($className, Tile::class)) throw new StrutsConfigException('Not a subclass of '.Tile::class.': '.$className);

        $this->tilesClass = $className;
    }
724371
protected function register($className, $type, $requiredBaseClass) {
        // check if the class is available for TYPO3 before registering the driver
        if (!class_exists($className)) {
            throw new \InvalidArgumentException('Class ' . $className . ' does not exist.', 1462883324);
        }

        if (!is_subclass_of($className, $requiredBaseClass)) {
            throw new \InvalidArgumentException('Parser ' . $className . ' needs to extend the ' . $requiredBaseClass . '.', 1462883325);
        }

        $this->classMap[$type] = $className;
    }
659748
protected function registerCoreBootstrappers()
    {
        foreach ($this->getBootStrappers() as $key => $class) {
            $this->container->set($key, $this->compose('\\'.$class));
        }

        $this->bootstrappers->execute();

        return $this;
    }
108214
public function registerType($typeName, $className)
    {
        if (isset($this->bindings[$typeName])) {
            throw new \InvalidArgumentException("`$typeName` is already registerd.");
        }

        $type = new \ReflectionClass($typeName);
        $class = new \ReflectionClass($className);
        $this->bindings[$typeName] = new Service($type, $class);

        return $this;
    }
670150
public function detect($className)
    {
        if (!empty($this->cachedRoutes[$className])) {
            return $this->cachedRoutes[$className];
        }
        $this->cachedRoutes[$className] = parent::detect($className);

        return $this->cachedRoutes[$className];
    }
107682
public static function registerEvent($name, $className)
    {
        if (isset(static::$eventList[$name]) === false) {
            static::$eventList[$name] = array();
        }
        static::$eventList[$name][$className] = $className;
    }
730176
public function addClass($className){

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

        $this->setFormClass($formClass);

        return $this;
    }
903002
public function addAlias(string $name, string $className)
    {
        $this->aliases[$name] = $className;
        return $this;
    }