Register class footprint

@param $className
@param ClassFootprint $footprint

@return $this
358310
public function registerFootprint($className, ClassFootprint $footprint)
    {
        $this->_builder->registerFootprint($className, $footprint);
        return $this;
    }
54989
public function canCreate(string $className): bool
    {
        return !empty($this->entityManager->getClassMetadata($className)->associationMappings);
    }
1187599
public static function instance($className = __CLASS__)
    {
        if (!isset(self::$instances[$className])) {
            self::$instances[$className] = new $className;
        }

        return self::$instances[$className];
    }
1046836
public function addConfigurationObject(ClassName $className, ObjectInterface $configurationObject): self
    {
        $this->objects[$className->getIdentifier()] = $configurationObject;

        return $this;
    }
498820
public function setClassName($className)
    {
        Assert::stringNotEmpty($className, 'The class name must be a non-empty string. Got: %s');

        $pos = strrpos($className, '\\');

        if (false === $pos) {
            $this->namespaceName = '';
            $this->shortClassName = $className;
        } else {
            $this->namespaceName = substr($className, 0, $pos);
            $this->shortClassName = substr($className, $pos + 1);
        }

        return $this;
    }
929337
public function registerCollectorClass($className)
    {
        /** @var CollectorInterface $collector */
        $collector = new $className($this->context->getProcess(), $this->datasource);
        $this->registerCollector($collector);
    }
290440
public function registerFormWidget($className, $widgetInfo = null)
    {
        if (!is_array($widgetInfo)) {
            $widgetInfo = ['code' => $widgetInfo];
        }

        $widgetCode = $widgetInfo['code'] ?? null;

        if (!$widgetCode) {
            $widgetCode = Str::getClassId($className);
        }

        $this->formWidgets[$className] = $widgetInfo;
        $this->formWidgetHints[$widgetCode] = $className;
    }
850234
public function bindRuleToClass ($identifier, $className)
		{
			$this->classIndex->setRuleToClass($identifier, $className);

			$this->rules[$identifier] = new ClassBindingRule($this, $this->classIndex, $className);

			return $this;
		}
331343
public function cloneInstance($className): self
	{
		// Determine the class to load
		$instanceName = strtolower($className);

		if (!isset($this->{$instanceName}))
		{
			throw new FactoryException("Could not clone instance of '".$instanceName."'. Instance was not found.", 1);
		}

		// Clone the instance
		$this->{$instanceName} = clone $this->{$instanceName};

		// Return itself
		return $this;
	}
579778
public static function register(Shell $shell, $classMapPath)
    {
        return tap(new static($shell, $classMapPath), function ($loader) {
            spl_autoload_register([$loader, 'aliasClass']);
        });
    }
408879
public function setClass($className)
    {
        $this->attributes->removeAttributeClass($this->iconPrefixClass . '-*');
        $this->attributes->addAttributeClass($this->iconPrefixClass . '-' . $className);

        return $this;
    }
994060
protected function registerBootChecker()
    {
        $this->app->singleton(Component::BOOTCHECKER, $this->getCoreConfig('bindings.' . Component::BOOTCHECKER));

        $this->app->bind(BootCheckerInterface::class, Component::BOOTCHECKER);

        return $this;
    }
328905
public static function registerRegistry(string $name, string $className, bool $replace = false)
    {
        if (!array_key_exists($name, self::$registries) or $replace) {
            self::$registries[$name] = $className;
        }
    }
1156346
private function registerBase()
    {
        if (!empty(Config::get('cache')) && Config::get('cache') instanceof CacheInterface) {
            $this['cache'] = Config::get('cache');
        } else {
            $this['cache'] = function () {
                return new FilesystemCache(sys_get_temp_dir());
            };
        }
    }
50634
public function newManager($classname) {
		$profile = Profiler::getClassProfile($classname);
		if (!$profile->isEntity())
			throw new \InvalidArgumentException(sprintf("Class %s is not declared as an entity", $profile->reflectionClass->getName()));
		return new Manager($this, $profile);
	}
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;
            }
        }
    }
107682
public static function registerEvent($name, $className)
    {
        if (isset(static::$eventList[$name]) === false) {
            static::$eventList[$name] = array();
        }
        static::$eventList[$name][$className] = $className;
    }