{@link Reflections} bean.

@return bean
168666
@Bean
    public Reflections reflections() {
        return new Reflections(new ConfigurationBuilder()
                                    .setUrls(ClasspathHelper.forPackage(scanPackage))
                                    .setScanners(new MethodAnnotationsScanner()));
    }
939474
public Object defineBean(String name, Object bean) {
        Object ret = getELContext().getBeans().get(name);
        getELContext().getBeans().put(name, bean);
        return ret;
    }
233961
public function make()
    {
        if (($params = $this->canBuild())) {
            $reflectionClass = new \ReflectionClass($this->className);
            $object = $reflectionClass->newInstanceArgs(is_array($params) ? $params : []);
            /**
             * Reset the object by removing default values used for typehinting
             * Then add our dependancies
             */
            $this->resetObject($object);
            foreach ($this->params as $key => $value) {
                $object->with($value, (is_numeric($key) ? null : $key));
            }
            $object->freeze();
            return $object;
        }
        return $this;
    }
169587
private static function prepareBean($bean) {
        $class = new \ReflectionClass(get_class($bean));
        if ($class->hasMethod('_initialize')) {
            self::invokeWithIocParams($bean, "_initialize");
            static::$injectBeans[] = $bean;
            if (static::$injectBeans[ 0 ] === $bean) {
                for ($i = count(static::$injectBeans) - 1; $i > -1; $i--) {
                    $class = new \ReflectionClass(get_class(static::$injectBeans[ $i ]));
                    if ($class->hasMethod('_prepared')) {
                        static::$injectBeans[ $i ]->_prepared();
                    }
                }
                static::$injectBeans = array();
            }
        }
    }
998144
public function getConstructor()
    {
        if (!isset($this->constructor)) {
            $this->constructor = new ProxyConstructor($this->fullOriginalClassName);
            $this->constructor->injectReflectionService($this->reflectionService);
        }
        return $this->constructor;
    }
481150
public final BeanConfig getConfig() {
    if (null == config) {
      config = new BeanConfig(getClass().getName());
      doBinding();
    }
    return config;
  }
840983
public static <T> T getInstance(Class<T> beanClass, String beanName) {
		return (T) getInstanceProvider().getInstance(beanClass, beanName);
	}
39612
public static function __instance()
        {
            if (empty(self::$__instance)) {
                self::$__instance = with(new \ReflectionClass(self::$__class))->newInstanceArgs(self::$__args);
            }

            return self::$__instance;
        }
5018
public BeanType<ConstraintMappingsType<T>> getOrCreateBean()
   {
      List<Node> nodeList = childNode.get("bean");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new BeanTypeImpl<ConstraintMappingsType<T>>(this, "bean", childNode, nodeList.get(0));
      }
      return createBean();
   }
535904
public function current()
    {
        $module = $this->query->getFromBean()->module_name;
        return \BeanFactory::retrieveBean($module, $this->key(), $this->retrieve_params);
    }
1084496
private function doGetReflector()
    {
        switch ($this->getType()) {
            case static::C_TYPE_FUNCTION:
            case static::C_TYPE_CLOSURE:
                return new \ReflectionFunction($this->handler);
            case static::C_TYPE_STATIC_METHOD:
            case static::C_TYPE_INSTANCE_METHOD:
                return new \ReflectionMethod($this->getClass(), $this->getMethod());
            case static::C_TYPE_INVOKED_OBJECT:
                return new \ReflectionMethod($this->getClass(), '__invoke');
            case static::C_TYPE_ERROR:
                throw new \Exception;
                break;
        }
    }
560520
private <T> T getReference(final Bean<T> bean) {
        T ret = (T) beanReferences.get(bean);

        if (null != ret) {
            return ret;
        }

        ret = bean.create();

        if (null != ret) {
            beanReferences.put(bean, ret);

            return ret;
        }

        throw new RuntimeException("Can't create reference for bean [" + bean + "]");
    }
1240118
protected function getReflection() {
		if ($this->reflection === null) {
			try {
				$this->reflection = new ReflectionClass($this->class);
			} catch (ReflectionException $exception) {
				throw new InitializationFailure('Error occurred while service initialization by class "' . $this->class . '"', 0, $exception);
			}
		}
		
		return $this->reflection;
	}
479708
public BeanId getBeanId() {
        if (ivBeanId == null) {
            ivBeanId = new BeanId(ivBMD.j2eeName, null, false);
        }
        return ivBeanId;
    }
1060954
@SuppressWarnings("unchecked")
	public static <T> T getInstance(String beanName) {
		return (T) getInstanceProvider().getInstance(beanName);
	}
1284628
public function getReflection(): ClassReflection
    {
        if (null === $this->reflection) {
            $this->reflection = new ClassReflection($this->documentClass);
        }

        return $this->reflection;
    }
427735
public function getReflectionClass()
    {
        if (!$this->reflClass) {
            $this->reflClass = new \ReflectionClass($this->getClassName());
        }

        return $this->reflClass;
    }