Call all of the "after" callbacks for the event.

@param  \Illuminate\Contracts\Container\Container  $container
@return void
357690
protected function callAfterCallbacks(Container $container)
	{
		foreach ($this->afterCallbacks as $callback)
		{
			$container->call($callback);
		}
	}
979932
public function process(ContainerBuilder $container)
    {
        $this->container = $container;
        $this->signalingException = new RuntimeException('Invalid reference.');

        try {
            $this->processValue($container->getDefinitions(), 1);
        } finally {
            $this->container = $this->signalingException = null;
        }
    }
58009
protected function setDependencies(Container $container)
    {
        parent::setDependencies($container);

        $this->setLocales($container['locales/manager']->locales());
    }
378954
protected function runForegroundProcess(Container $container)
    {
       $this->exitcode = (new Process($this->buildForegroundCommand(), base_path(), null, null, null))->run();
    }
617552
public function run(Container $container)
    {
        if ((! $this->ignoreMutex) && $this->description && $this->withoutOverlapping && (! $this->setMutex())) {
            return;
        }

        $this->runCommandInForeground($container);

        return $this->exitcode;
    }
596920
public function process(ContainerBuilder $container)
    {
        foreach ($container->findTaggedServiceIds($this->baseTag) as $id => $services) {
            foreach ((array) $services as $service) {
                $this->findAndReplaceTaggedServices($id, $service, $container);
            }
        }
    }
889589
public function after($callback)
    {
        $container  = Container::getInstance();

        $this->on('after', function ($request, $response) use (&$container, &$callback) {
            try {
                $container->call($callback, func_get_args());
            } catch (\Exception $e) {
                $this->emit('error', [$request, $response, $e->getMessage()]);
            }
        });
    }
374362
public function boot( Container $container ) {
		add_action( 'admin_init', [ $this->proxy( $container, 'options_page' ), 'admin_init' ] );
		add_action( 'admin_menu', [ $this->proxy( $container, 'options_page' ), 'admin_menu' ] );
		add_action(
			'admin_notices',
			[ $this->proxy( $container, 'options_page' ), 'print_notice_when_no_notifiers_active' ]
		);
		add_action(
			'admin_init',
			[ $this->proxy( $container, 'options_manager' ), 'register_settings' ]
		);
		add_action( 'soter_run_check', [ $this->proxy( $container, 'check_site_job' ), 'run' ] );
		add_action(
			'soter_site_check_complete',
			[ $this->proxy( $container, 'notifier_manager' ), 'notify' ]
		);

		$this->boot_upgrader( $container );
	}
857663
public function build(ContainerBuilder $container)
    {
        $this->initAdmingeneratorClassLoader($container);

        parent::build($container);

        $container->addCompilerPass(new ValidatorCompilerPass());
        $container->addCompilerPass(new FormCompilerPass());
    }
1192067
public function handle(Container $container)
    {
        $class = new \ReflectionClass(get_class($this->methodInvocation->getThis()));
        if ($class->getFileName()) {
            $method = $this->methodInvocation->getMethod()->getName();
            $container->call(
                [
                    $this->methodInvocation->getThis(),
                    $method,
                ],
                $this->methodInvocation->getArguments()->getArrayCopy()
            );
        }
    }
805925
public function process(ContainerBuilder $container)
    {
        $this->bag = $container->getParameterBag();

        try {
            parent::process($container);

            $aliases = array();
            foreach ($container->getAliases() as $name => $target) {
                $this->currentId = $name;
                $aliases[$this->bag->resolveValue($name)] = $target;
            }
            $container->setAliases($aliases);
        } catch (ParameterNotFoundException $e) {
            $e->setSourceId($this->currentId);

            throw $e;
        }

        $this->bag->resolve();
        $this->bag = null;
    }
1214866
public function boot(Container $container)
    {
        error_reporting($this->config->get('system.error_reporting', 0));

        /** @var ErrorManager $handler */
        $handler = $container->get(ErrorManager::class);

        $handler->setErrorTemplate(
            $this->config->get('error.template', 'windwalker.error.default'),
            $this->config->get('error.engine', 'php')
        );

        $handler->register(true, null, true);
    }
1271601
public function process(ContainerBuilder $container)
    {
        $this->processDriverPass($container);
        $this->processDriverElementPass($container);
        $this->processEventSubscriberPass($container);
        $this->processClassGenerator($container);

        $this->setPageObjectNamespaces($container);
        $this->injectSiteUrlIntoPageObjects($container);
    }
378873
public function run(Container $container)
	{
		if ($this->description)
		{
			touch($this->mutexPath());
		}

		try {
			$response = $container->call($this->callback, $this->parameters);
		} catch (\Exception $e) {
			$this->removeMutex();

			throw $e;
		}

		$this->removeMutex();

		parent::callAfterCallbacks($container);

		return $response;
	}
777277
public function roleForm(Container $container): void
	{
		$roles = ['' => $this->translate('form.none')] + $this->orm->aclRoles->fetchPairs($this->viewSuperadmin);
		$container->addText('title', 'cms.permissions.role')
			->setRequired();
		$container->addText('name', 'cms.permissions.name')
			->setRequired();
		$container->addSelect('parent', $this->translate('cms.permissions.parent'))
			->setTranslator()
			->setItems($roles);
	}
681391
public function process(ContainerBuilder $container)
    {
        $this->container = $container;
        foreach ($container->getDefinitions() as $definition) {
            if ($definition->isSynthetic() || $definition->isAbstract()) {
                continue;
            }

            $definition->setArguments(
                $this->processArguments($definition->getArguments())
            );

            $calls = array();
            foreach ($definition->getMethodCalls() as $call) {
                try {
                    $calls[] = array($call[0], $this->processArguments($call[1], true));
                } catch (RuntimeException $e) {
                    // this call is simply removed
                }
            }
            $definition->setMethodCalls($calls);

            $properties = array();
            foreach ($definition->getProperties() as $name => $value) {
                try {
                    $value = $this->processArguments(array($value), true);
                    $properties[$name] = reset($value);
                } catch (RuntimeException $e) {
                    // ignore property
                }
            }
            $definition->setProperties($properties);
        }
    }
907387
public function afterAction($event)
    {
        if ($this->schedule) {
            if ($event->result === false) {
                $exitCode = CronScheduleStatus::ERROR;
            } else {
                $exitCode = CronScheduleStatus::SUCCESS;
            }
            $this->schedule->endCronSchedule($exitCode);
            $this->schedule = null;
        }
    }