Load the configuration if necessary and forward the call to the parent.
438647
def get(self, *args, **kw):
        """"""
        if not self._loaded:
            self.load_config()
        return super(FedmsgConfig, self).get(*args, **kw)
649491
public function loadPluginConfiguration(): void
	{
		$builder = $this->getContainerBuilder();
		$global = $this->compiler->getExtension()->getConfig();
		$config = $this->getConfig();

		$builder->addDefinition($this->prefix('entityAdapter'))
			->setFactory(EntityAdapter::class);

		$entityDefinition = $builder->addDefinition($this->prefix('entityDefinition'))
			->setFactory(EntityDefinition::class);

		$coreDefinition = $builder->addDefinition($this->prefix('coreDefinition'))
			->setFactory(CoreDefinition::class);

		$schemaBuilder = $builder->addDefinition($this->prefix('schemaBuilder'))
			->setFactory(SchemaBuilder::class);

		if ($config['definitions'] === null) {
			$schemaBuilder
				->addSetup('addDefinition', [new BaseDefinition()])
				->addSetup('addDefinition', [$entityDefinition])
				->addSetup('addDefinition', [$coreDefinition]);
			foreach ($config['files'] as $file) {
				if (Strings::endsWith($file, '.neon')) {
					$schemaBuilder->addSetup('addDefinition', [new NeonDefinition($file)]);
				} elseif (Strings::endsWith($file, '.yaml') || Strings::endsWith($file, '.yml')) {
					$schemaBuilder->addSetup('addDefinition', [new YamlDefinition($file)]);
				} elseif (Strings::endsWith($file, '.json')) {
					$schemaBuilder->addSetup('addDefinition', [new JsonDefinition($file)]);
				} else {
					throw new InvalidArgumentException(sprintf(
						'We cant parse file "%s" - unsupported file type',
						$file
					));
				}
			}

			$schemaBuilder->addSetup('addDefinition', [new ArrayDefinition($config['definition'])]);
		} else {
			foreach ($config['definitions'] as $customDefinition) {
				$schemaBuilder->addSetup('addDefinition', [$customDefinition]);
			}
		}

		if ($global['debug'] !== true) {
			return;
		}

		if ($config['swaggerUi']['panel']) {
			$builder->addDefinition($this->prefix('swaggerUi.panel'))
				->setFactory(SwaggerUIPanel::class)
				->addSetup('setUrl', [$config['swaggerUi']['url']])
				->addSetup('setExpansion', [$config['swaggerUi']['expansion']])
				->addSetup('setFilter', [$config['swaggerUi']['filter']])
				->addSetup('setTitle', [$config['swaggerUi']['title']])
				->setAutowired(false);
		}
	}
779898
public function loadConfiguration(): void
	{
		$this->validateConfig($this->defaults);
		$builder = $this->getContainerBuilder();

		$builder->addDefinition($this->prefix('parsedown'))
			->setFactory(ParsedownExtraAdapter::class);
	}
784052
def _load(self):
        """"""
        for attr_name, config_prop in self._iter_config_props():
            found = False
            for loader in self._loaders:
                if loader.exists(config_prop.property_key):
                    raw_value = loader.get(config_prop.property_key)
                    converted_value = config_prop.load(raw_value)

                    self._set_instance_prop(attr_name, config_prop, converted_value)
                    found = True
                    break

            if not found:
                if not config_prop.required or config_prop.default is not None:
                    self._set_instance_prop(attr_name, config_prop, config_prop.default)
                else:
                    raise ValueError('Missing required ConfigProperty {}'.format(attr_name))
1298882
def iter_up(self, include_self=True):
        """"""
        if include_self: yield self
        parent = self.parent
        while parent is not None:
            yield parent
            try:
                parent = parent.parent
            except AttributeError:
                return
795884
public function loadConfiguration(): void
	{
		$builder = $this->getContainerBuilder();

		$builder->addDefinition($this->prefix('request'))
			->setType(Psr7Request::class)
			->setFactory(Psr7RequestFactory::class . '::fromNette');

		$builder->addDefinition($this->prefix('response'))
			->setType(Psr7Response::class)
			->setFactory(Psr7ResponseFactory::class . '::fromNette');
	}
489420
protected void load() {
        if (loader == null) {
            setInfiniteScrollLoader(new InfiniteScrollLoader());
        }

        offset = loadConfig.getOffset();
        limit = loadConfig.getLimit();
        load(offset, limit);
    }
59654
protected function loadConfiguration()
    {
        try {
            $configuration = $this->configurationStorage->loadFromFile()->get();
        } catch (NoConfigurationException $e) {

            $this->io->comment($e->getMessage());

            if (!$this->secret) {
                $this->secret = $this->io->ask('Secret');
            }
            $configuration = $this->parseConfigurationKey();
        }
        $this->serverUrl = $configuration['socket_url'];
        $this->secret = $configuration['secret'];
        $this->configurationStorage->merge($configuration)->save();
    }
578389
public function loadConfiguration(): void
	{
		$builder = $this->getContainerBuilder();

		$builder->addDefinition($this->prefix('client'))
			->setFactory(CurlClient::class);
	}
1132577
private function load()
    {
        $this->registry[$this->section] = $this->getDrupalCommonConnector()->variable_get($this->section, array());
    }
696324
def _load(self):
        """"""
        self.is_running = True
        self.pair_generator = self._iterator(self.plugins,
                                             self.context)
        self.current_pair = next(self.pair_generator, (None, None))
        self.current_error = None
        self.is_running = False
585262
protected function loadRoutesFromConfig() {
        $config = $this->config->getRaw('routing', []);
        $this->routerConfigurator->processConfig($this->router, $config);
    }
1136304
public function load()
    {
      $args = Ensure::Input(func_get_args());
      $props = $args->get();
      foreach ($props as $k => $prop)
        $this->{$k} = $prop;
    }
94923
def load(self, _override=True, _allow_undeclared=False, **kwargs):
    """"""
    self.load_from_dict(
        kwargs, _override=_override, _allow_undeclared=_allow_undeclared)
1108156
public function load()
    {
        foreach ($this->definitions as $tag => $definition) {
            $this->extendContainer($tag, $definition);
        }
    }
574623
def load(self):
        
        s = load_stack(self)
        if s:
            self.hooks = s.hooks
            self.calls = s.calls
1013648
private final function loadConfig(): void
    {
        $this->config = new Config();

        $file = sprintf('%s/app/service/%s/config/config.php', APP_DIR, $this->name);
        if (file_exists($file) && is_array($data = include $file)) {
            $this->config->setData($data);
        }
    }