Load Service

@return  void
553649
public function register()
	{
		// Bind the actual rate limiter
		$this->app['ratelimiter'] = function($app)
		{
			// creat new storage object
			$storage = new Storage\Database($app['db']);

			// Get rate limit config (JSON encode/decode to get as array)
			$config = json_decode(json_encode($app['config']->get('rate_limit')), true);
			$config = (is_array($config)) ? $config : [];

			// Create and return new rate limiter
			return new RateLimiter($storage, $config);
		};
	}
578389
public function loadConfiguration(): void
	{
		$builder = $this->getContainerBuilder();

		$builder->addDefinition($this->prefix('client'))
			->setFactory(CurlClient::class);
	}
64029
public function load(): void
    {
        $refl = new \ReflectionClass(GeneralUtility::class);

        $this->loadClassNameCache($refl);
        $this->loadInstanceCache($refl);
    }
872049
protected function setupServices(): void
   {
       $service_factory = new Services\ServiceFactory($this);
       foreach($this->config()->services->toArray() as $key => $service) {
           $this[$key] = $this->share( function($c) use($key, $service, $service_factory) {
             try {
               return $service_factory->create($key, $service['type'], $service['uri']); 
             }
             catch(AdapterNonExistentException $e) {
              $this->logger()->warning("The service %s - %s does not exist.", $key, $service['type']);
             }
        });
       }
   }
639298
public static function load()
    {
        $session = Config::get('session');

        static::start($session['storage']);

        static::$instance->load(Cookie::get($session['cookie']));
    }
98338
protected function load()
    {
        if (!isset($_SESSION[$this->sessionKey])) {
            return;
        }
        $data = json_decode($_SESSION[$this->sessionKey], true);
        if (is_array($data)) {
            foreach ($data as $cookie) {
                $this->setCookie(new SetCookie($cookie));
            }
        } elseif (strlen($data)) {
            throw new \RuntimeException("Invalid cookie data");
        }
    }
301749
protected function loadServicesFromConfig()
    {
        foreach (Config::get('services', []) as $name => $service) {
            $service += [
                'shared' => false,
                'locked' => false,
                'definition' => []
            ];

            $this->container->set($name, $service['definition'], $service['shared'], $service['locked']);
        }
    }
166137
private function load()
    {
        if (\count($this->attributes)) {
            return;
        }

        $sessionBag         = $this->session->getBag($this->getSessionBagKey());
        $databaseSessionBag = $this->session->getBag($this->getDatabaseSessionBagKey());

        $this->attributes = \array_merge(
            (array) $sessionBag->get($this->getScope()),
            (array) $databaseSessionBag->get($this->getScope())
        );
    }
1210550
protected function load()
    {
        $tables = $this->fetchTables($this->schema);
        foreach ($tables as $table) {
            $blueprint = new Blueprint($this->connection->getName(), $this->schema, $table);
            $this->fillColumns($blueprint);
            $this->fillConstraints($blueprint);
            $this->tables[$table] = $blueprint;
        }
    }
1224073
public function load() {
		$this->load_comments = $this->it_has( 'load_coments', $this->options )
			? $this->options['load_comments']
			: false;
		$this->enqueue_assets();
	}
1283270
public function boot()
    {
        if (file_exists($routes = api_path('routes.php'))) {
            $this->loadRoutesFrom($routes);
        }

        if ($this->app->runningInConsole()) {
            $this->publishes([
                __DIR__ . '/../../config' => config_path()
            ], 'laravel-api-config');
        }
    }
1197812
public function load( $service ){
          
             // is overwrite class specified 
            $class = array_key_exists($service, $this->webServices)
                    ? new $this->webServices[$service]
                    : $this;
            
            $class->build( $service );
            
            return $class;
      }
947643
public function boot()
    {
        if ($this->booted) return;

        // Register service providers
        foreach ($this['config']->get('app.providers') as $provider) {
            $this->addProvider($provider);
        }

        // Register aliases
        AliasLoader::getInstance($this['config']->get('app.aliases'))->register();

        // Now run boot events on service providers
        array_walk($this->registered, function($p) {
            if (method_exists($p, 'boot')) $p->boot();
        });

        if (file_exists($bootstrap = $this->appPath."/bootstrap/{$this->mode}.php")) {
            require $bootstrap;
        }

        $this->booted = true;
    }
441267
public function load() {
        if ($this->_loaded) return;
        $factory = HTMLPurifier_LanguageFactory::instance();
        $factory->loadLanguage($this->code);
        foreach ($factory->keys as $key) {
            $this->$key = $factory->cache[$this->code][$key];
        }
        $this->_loaded = true;
    }
273201
private function load()
	{
		if ($this->isLoaded())
		{
			return;
		}

		$path = sprintf('%s/../../lang/%s.php', __DIR__, $this->locale);

		if (file_exists($path))
		{
			$this->loaded[$this->locale] = require $path;
		}
	}
158577
protected static function load()
    {
        need(root().'app/http/Filter.php');

        $filter = instance(\App\Http\Filter::class);

        self::$filters['app'] = $filter::$middleware;
        self::$filters['route'] = $filter::$routeMiddleware;

        return self::$filters;
    }
267249
private function load()
    {
        if ($this->config === null) {
            $this->config = [];
            $localPath = '/conf/dependencies.php';
            $appRoot = $this->env->getBootstrap()->getAppRoot();
            $fs = $this->env->getFileSystem();
            if ($fs->fileExists($appRoot . $localPath)) {
                /** @noinspection PhpIncludeInspection */
                $this->config = require_once($fs->getRealPath($appRoot . $localPath));
            }
        }
    }