Get the facade for SDK

@param $className

@return mixed
@throws Exception\RuntimeException
515577
public function create($className)
        {
            $facade = $this->helper->getFacadeClassName($className);

            if (!class_exists($facade)) {
                throw new RuntimeException("Class '$facade' not found");
            }
            $className = $this->helper->getSDKClassName($className);
            return new $facade(new $className($this->httpClient));
        }
1320788
public static function instantiate($className)
    {
        $objectManager = self::get()->getObjectManager();
        $args = func_get_args();

        if (1 === count($args)) {
            return $objectManager->get($className);
        }

        return call_user_func_array([$objectManager, 'get'], $args);
    }
723926
private function getNewEmbeddableFqnFromClassName(string $className): string
    {
        return $this->namespaceHelper->tidy(
            $this->projectRootNamespace . '\\'
            . implode('\\', \array_slice($this->archetypeObjectSubDirectories, 1))
            . '\\' . $className
        );
    }
954469
public final function get($className)
   {
       if (!$this->has($className)) {
           throw new NotFoundException(
               "Can't get " . $className . ": not found");
       } else if (is_callable($this->service[$className])) {
           $args = func_get_args();
           $args[0] = $this;
           try {
               $this->service[$className] = $this->service[$className](...$args);
           } catch (Throwable $e) {
               throw new ContainerException(
                   "Can't get " . $className . ": " . $e->getMessage());
           }
       }
       return $this->service[$className];
    }
1010933
protected function findFile($className)
    {
        $genDir = $this->getGenerationDir();

        if (!$genDir) {
            return null;
        }

        $path = [$genDir];
        $path[] =  str_replace('\\', DIRECTORY_SEPARATOR, $className) . '.php';

        $path = implode(DIRECTORY_SEPARATOR, $path);

        $dir = dirname($path);

        if (!is_dir($dir) && !@mkdir($dir, 0777, true)) {
            $e = error_get_last();
            throw new \RuntimeException(
                "Failed to create class generation folder: " . $e['message']
            );
        }

        return $path;
    }
424829
public function getModelVersion($className) {
        $version = '1.0';
        $className= $this->loadClass($className);
        if ($className && isset($this->map[$className]['version'])) {
            $version= $this->map[$className]['version'];
        }
        return $version;
    }
461238
public static function getInstance($className = '')
    {
        if ($className !== '') {
            try {
                $ref = new \ReflectionClass($className);
                if ($ref->isSubclassOf('\MehrAlsNix\Notifier\Notification')) {
                    self::$instance = $ref->newInstance();
                }
            } catch (\ReflectionException $re) {
                throw new \RuntimeException($re->getMessage());
            }
        } elseif (!self::$instance instanceof Notification) {
            self::$instance = self::fetch();
        }

        return self::$instance;
    }
1264539
protected function getMethodReflection($className, $methodName)
    {
        $this->dataCacheNeedsUpdate = true;
        if (!isset($this->methodReflections[$className][$methodName])) {
            $this->methodReflections[$className][$methodName] = new MethodReflection($className, $methodName);
        }
        return $this->methodReflections[$className][$methodName];
    }
614219
private function buildAndCacheFromFactory(string $className)
    {
        $factory  = self::$cachedInstantiators[$className] = $this->buildFactory($className);
        $instance = $factory();

        if ($this->isSafeToClone(new ReflectionClass($instance))) {
            self::$cachedCloneables[$className] = clone $instance;
        }

        return $instance;
    }
1234532
private static function getInstance(string $className): string
    {
        $collector = EntityCollector::getCollector();
        if (!isset($collector[$className]['instance'])) {
            return Pool::INSTANCE;
        }

        return $collector[$className]['instance'];
    }
1180034
public function getMetadataFor($className)
    {
        if (isset($this->mapping[$className])) {
            return $this->mapping[$className];
        }

        $metadata   = new ClassMetadata();
        $reflection = new ReflectionClass($className);

        $metadata->className      = $reflection->name;
        $metadata->riakProperties = $this->getRiakPropertiesMapping($reflection);

        return $this->mapping[$className] = $metadata;
    }
514225
public function get($name)
    {
        if (isset($this->instances[$name])) {
            return $this->instances[$name];
        }
        if (! isset($this->registry[$name])) {
            $exceptionClass = static::NOT_FOUND_EXCEPTION;
            throw new $exceptionClass(
                sprintf(static::NOT_FOUND_MESSAGE, $name)
            );
        }
        try {
            $this->instances[$name] = $this->build($this->registry[$name], $name);
        } catch (Exception $e) {
            throw new RuntimeException(
                sprintf(static::BUILD_FAILURE_MESSAGE, $name),
                null,
                $e
            );
        }

        return $this->instances[$name];
    }
415983
private function getReflection(string $className) : \ReflectionClass
    {
        if (empty($this->reflectionContainer[$className])) {
            $this->reflectionContainer[$className] = new \ReflectionClass($className);
        }

        return $this->reflectionContainer[$className];
    }
158347
public function getMetadataFor($className)
    {
        if (!$this->isService($className)) {
            throw Exception::classIsNotMappedService($className);
        }

        if (!isset($this->loadedMetadata[$className])) {
            $this->loadMetadata($className);
        }

        if ($this->cache) {
            $cacheId = $this->cachePrefix . $className . $this->cacheSuffix;

            if (($cached = $this->cache->fetch($cacheId)) !== false) {
                $this->loadedMetadata[$className] = $cached;
            } else {
                $this->loadMetadata($className);
                $this->cache->save($cacheId, $this->loadedMetadata[$className], null);
            }
        } else {
            $this->loadMetadata($className);
        }

        return $this->loadedMetadata[$className];
    }
1288802
public function getJsonConverter($className)
    {
        switch ($className) {
            case 'Puli\Manager\Api\Config\ConfigFile':
                return $this->container->getConfigFileConverter();

            case 'Puli\Manager\Api\Module\ModuleFile':
                return $this->container->getLegacyModuleFileConverter();

            case 'Puli\Manager\Api\Module\RootModuleFile':
                return $this->container->getLegacyRootModuleFileConverter();

            default:
                throw new InvalidArgumentException(sprintf(
                    'Could not find converter for class "%s".',
                    $className
                ));
        }
    }
1238711
public function get($className)
    {
        if (isset($this->_footprints[$className])) {
            return $this->_footprints[$className];
        }

        if (isset($this->_data[$className])) {
            $data = $this->_data[$className];
            $footprint = new ClassFootprint($data);
        } else {
            $footprint = new ClassFootprint();
            if (preg_match($this->_interfaceRegex, $className)) {
                $footprint->setType(ClassFootprint::TYPE_INTERFACE);
            }
        }
        $this->addFootprint($className, $footprint);

        return $footprint;
    }
1068431
public function get($attrName)
    {
        if (!self::isClassAttribute($this->className, $attrName)) {
            throw new Exception\RuntimeException(
                sprintf(
                    "Trying to get unknown attribute '%s' for class '%s'",
                    $attrName,
                    $this->className
                )
            );
        }
        return isset($this->attributes[$attrName]) ?
                $this->attributes[$attrName] : null;
    }