Reloads the configuration.
483116
public function reload()
    {
        $this->configuration = null;

        $this->load($this->domDocument, $this->cachePath, $this->xmlSchemaFile);
    }
1082188
public function reload()
    {
        if ($this->presenter->isAjax()) {
            $this->presenter->payload->grido = TRUE;
            $this->redrawControl();
        } else {
            $this->redirect('this');
        }
    }
838910
def reload(self):
        """"""
        self.read_notmuch_config(self._notmuchconfig.filename)
        self.read_config(self._config.filename)
1171634
public function reload()
    {
        $this->propertyCache = [];

        $repository = $this->getRepository();
        $repository->reHydrateObject($this, $this->uniqueIdentifier);
    }
904810
public void reloadClasses()
    {
        File triggerDirectory = FBUtilities.cassandraTriggerDir();
        if (triggerDirectory == null)
            return;
        customClassLoader = new CustomClassLoader(parent, triggerDirectory);
        cachedTriggers.clear();
    }
1117763
public function reload()
    {
        $server = $this->createServerManager();

        if (!$server->isRunning()) {
            \output()->writeln('<error>The server is not running! cannot reload</error>', true, true);
        }

        \output()->writeln(sprintf('<info>Server %s is reloading</info>', input()->getScript()));

        $reloadTask = input()->hasOpt('t');
        $server->reload($reloadTask);
        \output()->writeln(sprintf('<success>Server %s reload success</success>', input()->getScript()));
    }
632375
def reload(self):
        
        for section in self.sections():
            self.remove_section(section)
        self.autoload()
1316729
public void reload() {

        List<CmsResource> settingConfigResources = new ArrayList<>();
        try {
            I_CmsResourceType type = OpenCms.getResourceManager().getResourceType(TYPE_SETTINGS_CONFIG);
            CmsResourceFilter filter = CmsResourceFilter.ONLY_VISIBLE_NO_DELETED.addRequireType(type);
            settingConfigResources.addAll(m_cms.readResources("/", filter));
        } catch (CmsException e) {
            LOG.warn(e.getLocalizedMessage(), e);
        }
        Map<CmsUUID, List<CmsXmlContentProperty>> settingConfigs = new HashMap<>();
        for (CmsResource resource : settingConfigResources) {
            parseSettingsConfig(resource, settingConfigs);
        }
        m_settingConfigs = settingConfigs;

        List<CmsResource> formatterResources = new ArrayList<CmsResource>();
        try {
            I_CmsResourceType type = OpenCms.getResourceManager().getResourceType(TYPE_FORMATTER_CONFIG);
            CmsResourceFilter filter = CmsResourceFilter.ONLY_VISIBLE_NO_DELETED.addRequireType(type);
            formatterResources.addAll(m_cms.readResources("/", filter));
        } catch (CmsException e) {
            LOG.warn(e.getLocalizedMessage(), e);
        }
        try {
            I_CmsResourceType type = OpenCms.getResourceManager().getResourceType(TYPE_MACRO_FORMATTER);
            CmsResourceFilter filter = CmsResourceFilter.ONLY_VISIBLE_NO_DELETED.addRequireType(type);
            formatterResources.addAll(m_cms.readResources("/", filter));
            I_CmsResourceType typeFlex = OpenCms.getResourceManager().getResourceType(TYPE_FLEX_FORMATTER);
            CmsResourceFilter filterFlex = CmsResourceFilter.ONLY_VISIBLE_NO_DELETED.addRequireType(typeFlex);
            formatterResources.addAll(m_cms.readResources("/", filterFlex));
            I_CmsResourceType typeFunction = OpenCms.getResourceManager().getResourceType(
                CmsResourceTypeFunctionConfig.TYPE_NAME);
            CmsResourceFilter filterFunction = CmsResourceFilter.ONLY_VISIBLE_NO_DELETED.addRequireType(typeFunction);
            formatterResources.addAll(m_cms.readResources("/", filterFunction));
        } catch (CmsException e) {
            LOG.warn(e.getLocalizedMessage(), e);
        }
        Map<CmsUUID, I_CmsFormatterBean> newFormatters = Maps.newHashMap();
        for (CmsResource formatterResource : formatterResources) {
            I_CmsFormatterBean formatterBean = readFormatter(formatterResource.getStructureId());
            if (formatterBean != null) {
                newFormatters.put(formatterResource.getStructureId(), formatterBean);
            }
        }
        m_state = new CmsFormatterConfigurationCacheState(newFormatters);

    }
969412
def reload
      # Make sure we have a fresh cache after we reload
      config.cache.clear if config.cache.respond_to?(:clear)

      # Reload dependencies as well, if necessary
      ActiveSupport::Dependencies.clear if defined?(ActiveSupport::Dependencies)

      # Use current configuration, but skip bundle and autoloading initializers
      current_config = config.marshal_dump.dup
      current_config.merge! :skip_bundle => true#, :skip_autoloading => true)

      initialize current_config
    end
1009094
def reload(self):
        
        self._load_data(self.objects.data().filter(key=self.key)[0][0], True)
1317964
public function reload()
    {
        $entity = $this->getRemoteEntity();
        $fetchMethod = $this->fetchMethod;
        $this->remoteModels = $entity->$fetchMethod($this->model);
        $this->initialized = true;
    }
1346830
def reload_configuration(self, event):
        """"""

        super(EnrolManager, self).reload_configuration(event)
        self.log('Reloaded configuration.')
        self._setup()
1058281
public void reload()
    {
        InfinispanCache.get().<UUID, SystemConfiguration>getCache(SystemConfiguration.UUIDCACHE).remove(uuid);
        InfinispanCache.get().<Long, SystemConfiguration>getCache(SystemConfiguration.IDCACHE).remove(id);
        InfinispanCache.get().<String, SystemConfiguration>getCache(SystemConfiguration.NAMECACHE).remove(name);
    }
130747
public void reload()
    {
        // figure out what needs to be added and dropped.
        // future: if/when we have modifiable settings for secondary indexes,
        // they'll need to be handled here.
        Collection<ByteBuffer> indexedColumnNames = indexesByColumn.keySet();
        for (ByteBuffer indexedColumn : indexedColumnNames)
        {
            ColumnDefinition def = baseCfs.metadata.getColumnDefinition(indexedColumn);
            if (def == null || def.getIndexType() == null)
                removeIndexedColumn(indexedColumn);
        }

        // TODO: allow all ColumnDefinition type
        for (ColumnDefinition cdef : baseCfs.metadata.allColumns())
            if (cdef.getIndexType() != null && !indexedColumnNames.contains(cdef.name.bytes))
                addIndexedColumn(cdef);

        for (SecondaryIndex index : allIndexes)
            index.reload();
    }
504844
private String reloadConfiguration() {
        String location = System.getProperty(APPLICATION_CONFIGURATION);
        if (location == null) {
            location = "conf/application.conf";
        }

        Config configuration = loadConfiguration(location);

        if (configuration == null) {
            throw new IllegalStateException("Cannot load the application configuration (" + location + ") - Wisdom cannot " +
                    "work properly without such configuration");
        }

        setConfiguration(configuration);

        return location;
    }
450793
def reload(self, reload_timeout=300, save_config=True):
        
        self.log("Reload not implemented on {} platform".format(self.platform))
203366
def _reload(self):
        
        ConfigModel = apps.get_model('djconfig.Config')
        cache = {}
        data = dict(
            ConfigModel.objects
                .all()
                .values_list('key', 'value'))

        # populate cache with initial form values,
        # then with cleaned database values,
        # then with raw database file/image paths
        for form_class in self._registry:
            empty_form = form_class()
            cache.update({
                name: field.initial
                for name, field in empty_form.fields.items()})
            form = form_class(data={
                name: _deserialize(data[name], field)
                for name, field in empty_form.fields.items()
                if name in data and not isinstance(field, forms.FileField)})
            form.is_valid()
            cache.update({
                name: _unlazify(value)
                for name, value in form.cleaned_data.items()
                if name in data})
            # files are special because they don't have an initial value
            # and the POSTED data must contain the file. So, we keep
            # the stored path as is
            # TODO: see if serialize/deserialize/unlazify can be used for this instead
            cache.update({
                name: data[name]
                for name, field in empty_form.fields.items()
                if name in data and isinstance(field, forms.FileField)})

        cache['_updated_at'] = data.get('_updated_at')
        self._cache = cache