creates list of bindings from given class

@internal
@param   string  $className    full qualified class name of class to create an instance of
@return  \stubbles\ioc\module\BindingModule[]
353349
protected static function getBindingsForApp(string $className): array
    {
        $bindings   = parent::getBindingsForApp($className);
        $bindings[] = function(Binder $binder)
        {
            $binder->bind(InputStream::class)
                   ->named('stdin')
                   ->toInstance(ConsoleInputStream::forIn());
            $binder->bind(OutputStream::class)
                   ->named('stdout')
                   ->toInstance(ConsoleOutputStream::forOut());
            $binder->bind(OutputStream::class)
                   ->named('stderr')
                   ->toInstance(ConsoleOutputStream::forError());
        };
        return $bindings;
    }
608413
public function create(string $className, string $typeName): Type
    {
        $typeName = Utils::getTypeName($className);
        $description = $this->getDescription($className);

        $fieldsGetter = function () use ($className): array {
            $factory = new OutputFieldsConfigurationFactory($this->types, $this->entityManager);
            $configuration = $factory->create($className);

            return $configuration;
        };

        return new ObjectType([
            'name' => $typeName,
            'description' => $description,
            'fields' => $fieldsGetter,
        ]);
    }
939552
private function createControllerFromClassName($className)
    {
        // If we can, use the container to build the Controller so that Constructor params can
        // be injected where possible
        if ($this->invoker) {
            return $this->invoker->getContainer()->get($className);
        }

        return new $className;
    }
983690
public static function getReferences($className) {
		$references = array();
		$reflection = ClassType::from($className);

		foreach ($reflection->getProperties() as $property) {
			if ($property->hasAnnotation("reference") === TRUE) {
				$ref = new \stdClass();
				$ref->property = $property->getName();
				if ($property->hasAnnotation("OneToOne") === TRUE) {
					$ref->linkage = "OneToOne";
					$linkage = $property->getAnnotation("OneToOne");
					$ref->targetEntity = $linkage->targetEntity;
					$ref->key = $linkage->mappedBy;
					$ref->canBeNULL = isset($linkage->canBeNULL) ? (boolean)$linkage->canBeNULL : FALSE;
				} elseif ($property->hasAnnotation("OneToMany") === TRUE) {
					$ref->linkage = "OneToMany";
					$linkage = $property->getAnnotation("OneToMany");
					$ref->targetEntity = $linkage->targetEntity;
					$ref->key = $linkage->mappedBy;
					$ref->canBeNULL = isset($linkage->canBeNULL) ? (boolean)$linkage->canBeNULL : FALSE;
				} elseif ($property->hasAnnotation("ManyToOne") === TRUE) {
					$ref->linkage = "ManyToOne";
					$linkage = $property->getAnnotation("ManyToOne");
					$ref->targetEntity = $linkage->targetEntity;
					$ref->key = $linkage->mappedBy;
					$ref->canBeNULL = isset($linkage->canBeNULL) ? (boolean)$linkage->canBeNULL : FALSE;
				} elseif ($property->hasAnnotation("ManyToMany") === TRUE) {
					$ref->linkage = "ManyToMany";
					$linkage = $property->getAnnotation("ManyToMany");
					$ref->targetEntity = $linkage->targetEntity;
					$ref->key = $linkage->mappedBy;
					$ref->canBeNULL = isset($linkage->canBeNULL) ? (boolean)$linkage->canBeNULL : FALSE;
				} else {
					throw new EntityException("Reference \"" . $className . "::$ref->property\" has no set linkage annotation type.");
				}

				$references[$ref->property] = $ref;
			}
		}
		return $references;
	}
1243977
public function getClassTagsValues($className)
    {
        if (!isset($this->reflectedClassNames[$className])) {
            $this->reflectClass($className);
        }
        if (!isset($this->classTagsValues[$className])) {
            return [];
        }
        return isset($this->classTagsValues[$className]) ? $this->classTagsValues[$className] : [];
    }
162961
public function create(string $className, string $typeName): Type
    {
        $description = 'To be used as a filter for objects of type `' . Utils::getTypeName($className) . '`';

        $fieldsGetter = function () use ($className, $typeName): array {
            $configuration = [
                [
                    'name' => 'groups',
                    'type' => Type::listOf(Type::nonNull($this->getGroupType($className, $typeName))),
                ],
            ];

            return $configuration;
        };

        $filterType = new InputObjectType([
            'name' => $typeName,
            'description' => $description,
            'fields' => $fieldsGetter,
        ]);
        $this->types->registerInstance($filterType);

        return $filterType;
    }
475986
public function generateCommandProxy($className)
    {
        $classMeta = $this->reflectionService->getClassMetaReflection($className);
        $proxies = [];

        $cachePath = $this->getRaptorCachePath();
        $this->createDirectory($cachePath);
        $thisNode = new Variable('this');

        foreach ($classMeta->getMethods() as $methodMeta) {

            // skip if method is not a command or an inherited command
            if (!stristr($methodMeta->getName(), self::COMMAND_SUFFIX) ||
                $methodMeta->getDeclaringClass() !== $classMeta) {
                continue;
            }

            $proxies[] = $this->generateProxyForMethod($cachePath, $thisNode, $methodMeta, $classMeta);
        }

        return $proxies;
    }
762288
protected function getClassIdFromModuleMap($className)
    {
        $moduleControllerMapProvider = $this->getModuleControllerMapProvider();
        $idToNameMap = $moduleControllerMapProvider->getControllerMap();
        $classId = $this->arrayLookup($className, array_flip($idToNameMap));

        return $classId;
    }
493771
public static function get_templates_for_class($classname)
    {
        $classes = ClassInfo::ancestry($classname);
        $classes = array_reverse($classes);
        $remove_classes = self::config()->classes_to_remove;
        $return = array();

        array_push($classes, "Catalogue", "Page");

        foreach ($classes as $class) {
            if (!in_array($class, $remove_classes)) {
                $return[] = $class;
            }
        }
        
        return $return;
    }
795976
protected static function getClassProperties($className)
    {
        if (\class_exists($className, true)) {
            $reflection = new ReflectionClass($className);
            $value = $reflection->newInstanceWithoutConstructor();

            if (\is_subclass_of($value, Model::class, true)) {
                $attributes = Schema::getColumnListing($value->getTable());

                self::$eloquentClasses[$className] = $attributes;
            }
        }

        return (!empty(self::$eloquentClasses[$className])) ? self::$eloquentClasses[$className] : parent::getClassProperties($className);
    }
929766
private function getCustomSortingNames(string $className): array
    {
        $this->fillCache($className);

        return array_keys($this->customSortings[$className]);
    }
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);
    }
567482
public static function getMethodsAnnotations($className, $annotationClassName = null)
    {
        if(null === $annotationClassName)
        {
            return static::$annotations[$className]['Methods'] ?? [];
        }
        $result = [];
        foreach(static::$annotations[$className]['Methods'] ?? [] as $methodName => $annotations)
        {
            foreach($annotations as $annotation)
            {
                if($annotation instanceof $annotationClassName)
                {
                    $result[$methodName][] = $annotation;
                }
            }
        }
        return $result;
    }
673247
protected function getRequiredModule(string $className) {
		if (\array_key_exists($className, $this->modules)) {
			return $this->modules[$className];
		} else {
			throw new ConfigurationException(__CLASS__ . ' tried to request module ' . $className .
				', but it was not listed as a dependency or has not yet added.');
		}
	}
763124
public function createClassBinding($binding)
    {
        return function ($value, $route) use ($binding) {
            // If the binding has an @ sign, we will assume it's being used to delimit
            // the class name from the bind method name. This allows for bindings
            // to run multiple bind methods in a single class for convenience.
            $segments = explode('@', $binding);
            $method = count($segments) == 2 ? $segments[1] : 'bind';
            $callable = [$this->container->make($segments[0]), $method];
            
            return call_user_func($callable, $value, $route);
        };
    }
99453
public function addClass($classname)
    {
        $classArr = $this->getClassArray();
        $classArr[] = $classname;
        return $this->setClassArray($classArr);
    }
934098
public function createClassConstantReference(string $className): ClassConstFetch
    {
        $nameNode = new FullyQualified($className);

        return $this->builderFactory->classConstFetch($nameNode, 'class');
    }