(non-PHPdoc)

@see OmiseApiResource::g_reload()
761006
public function reload()
    {
        if ($this['object'] === 'event') {
            parent::g_reload(self::getUrl($this['id']));
        } else {
            parent::g_reload(self::getUrl());
        }
    }
843932
public function reload(array $options = [])
    {
        return $this->policy = $this->connection->getPolicy([
            'resource' => $this->resource
        ] + $options + $this->options['args']);
    }
451325
protected function g_update($url, $params)
    {
        $result = $this->execute($url, self::REQUEST_PATCH, $this->getResourceKey(), $params);
        $this->refresh($result);
    }
810613
public function reload()
    {
        $class = $this->getRemoteClass();
        $count = false;
        $limit = null;
        if ($this->uniqueRemote) {
            $limit = 1;
        }
        $this->remoteModels = (new $class)->entity->fetchByRelated($this->relatedAttributeName, $this->model, $limit, null, $count, $this->filterList);
    }
1117575
function upgrade_reload($url) {
        return html_writer::empty_tag('br') .
                html_writer::tag('div',
                    html_writer::link($url, $this->pix_icon('i/reload', '', '', array('class' => 'icon icon-pre')) .
                            get_string('reload'), array('title' => get_string('reload'))),
                array('class' => 'continuebutton')) . html_writer::empty_tag('br');
    }
169159
private function load()
    {
        $filename = $this->path . '/domainparsertld.txt';

        if (file_exists($filename)) {
            $this->tldList = unserialize(file_get_contents($filename));

            // will reload tld list if timestamp of cache file is outdated
            if (time() - $this->tldList['timestamp'] > $this->cacheTime) {
                $this->reload = true;
            }

            // will reload tld list if changes to Additional.php have been made
            if ($this->tldList['timestamp'] < filemtime(__DIR__ .'/Additional.php')) {
                $this->reload = true;
            }
        }

        // check connection - if there is no internet connection skip loading
        $existFile = file_exists($filename);

        if (! $existFile || $this->reload === true) {
            $this->catchTlds($existFile);
            $file = fopen($filename, 'w+');

            if ($file === false) {
                throw AbstractException::factory('OpenFile', 'Could not open cache file.');
            }

            if (fwrite($file, serialize($this->tldList)) === false) {
                throw AbstractException::factory('WriteFile', 'Could not open cache file for writing.');
            }

            fclose($file);
        }

        $this->loaded = true;
    }
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()));
    }
687321
def reload(force=false)
      raise ArgumentError, 'Argument must be true or false.' unless [true, false].include?(force)
      if force || reload?
        flush_cache
        return true
      end
      false
    end
1349171
protected static function reload()
    {
        // For master process.
        if (static::$_masterPid === posix_getpid()) {
            // Set reloading state.
            if (static::$_status !== static::STATUS_RELOADING && static::$_status !== static::STATUS_SHUTDOWN) {
                static::log("Workerman[" . basename(static::$_startFile) . "] reloading");
                static::$_status = static::STATUS_RELOADING;
                // Try to emit onMasterReload callback.
                if (static::$onMasterReload) {
                    try {
                        call_user_func(static::$onMasterReload);
                    } catch (\Exception $e) {
                        static::log($e);
                        exit(250);
                    } catch (\Error $e) {
                        static::log($e);
                        exit(250);
                    }
                    static::initId();
                }
            }

            if (static::$_gracefulStop) {
                $sig = SIGQUIT;
            } else {
                $sig = SIGUSR1;
            }

            // Send reload signal to all child processes.
            $reloadable_pid_array = array();
            foreach (static::$_pidMap as $worker_id => $worker_pid_array) {
                $worker = static::$_workers[$worker_id];
                if ($worker->reloadable) {
                    foreach ($worker_pid_array as $pid) {
                        $reloadable_pid_array[$pid] = $pid;
                    }
                } else {
                    foreach ($worker_pid_array as $pid) {
                        // Send reload signal to a worker process which reloadable is false.
                        posix_kill($pid, $sig);
                    }
                }
            }

            // Get all pids that are waiting reload.
            static::$_pidsToRestart = array_intersect(static::$_pidsToRestart, $reloadable_pid_array);

            // Reload complete.
            if (empty(static::$_pidsToRestart)) {
                if (static::$_status !== static::STATUS_SHUTDOWN) {
                    static::$_status = static::STATUS_RUNNING;
                }
                return;
            }
            // Continue reload.
            $one_worker_pid = current(static::$_pidsToRestart);
            // Send reload signal to a worker process.
            posix_kill($one_worker_pid, $sig);
            // If the process does not exit after static::KILL_WORKER_TIMER_TIME seconds try to kill it.
            if(!static::$_gracefulStop){
                Timer::add(static::KILL_WORKER_TIMER_TIME, 'posix_kill', array($one_worker_pid, SIGKILL), false);
            }
        } // For child processes.
        else {
            reset(static::$_workers);
            $worker = current(static::$_workers);
            // Try to emit onWorkerReload callback.
            if ($worker->onWorkerReload) {
                try {
                    call_user_func($worker->onWorkerReload, $worker);
                } catch (\Exception $e) {
                    static::log($e);
                    exit(250);
                } catch (\Error $e) {
                    static::log($e);
                    exit(250);
                }
            }

            if ($worker->reloadable) {
                static::stopAll();
            }
        }
    }
23281
public function load($refresh = false, array $options = array())
    {
        if ($refresh || $this->_contents === null) {
            $this->_contents = @file_get_contents($this->_path);

            if ($this->_contents === false) {
                throw LoadException::create($this->_path);
            }

            $this->setContents($this->decode($options));
        }

        return $this;
    }
558421
public function reload()
    {
        if ($this->root !== $this) {
            $this->root->reload();
            return;
        }
        if (! isset($this->store)) {
            return;
        }
        if (! $this->store->touch()) {
            return;
        }
        try {
            $this->store->open(false);
            $this->data = $this->store->read();
        } catch (AccessException $e) {
            throw new AccessException('Could not read configration: ' . $e->getMessage(), null, $e);
        }
        $this->store->close();
    }
250256
public function reload()
    {
        $this->getPersistenceStorage()->setWURFLLoaded(false);
        $this->remove();
        $this->invalidateCache();
        $this->init();
        $this->getPersistenceStorage()->save(self::WURFL_API_STATE, $this->getState());
    }
901689
public function reload()
	{
		$this->_relationships = array();
		$pk = array_values($this->getValuesFor($this->getPrimaryKey()));

		$this->setAttributesViaMassAssignment($this->find($pk)->attributes, false);
		$this->resetDirty();

		return $this;
	}
240405
public function load($group = null, $index = false, $reload = true)
	{

		if (is_array($group)) {
			// Loading multiple config groups
			foreach ($group as $g) {
				$this->load($g, $index);
			}
		} else {

			if (empty($group)) {
				$group = 'default';
			}
			if ($index === true) {
				$index_group = $group;
			} else {
				$index_group = 'default';
			}
			if (!$reload && array_key_exists($group, $this->items)) {
				return $this->items[$group];
			}

			// First, grab any default items.
			$default_items = $this->provider->load($group);

			// Next, grab any environment-specific items.
			$environment_items = $this->provider->load($group, $this->environment);

			// Merge them together. Environment-specific items will replace default items.
			$items = self::array_merge_deep($default_items, $environment_items);

			// Add this config group to our index.
			foreach ($items as $key => $value) {
				$this->set($key, $value, $index_group);
			}

			// Return the items loaded in this call, NOT ALL the items in the config array.
			return $items;
		}
	}
601172
function reloadSites() {
    function reload() {
      sites.get()
      .then(function(sites) {
        $scope.ui.sites = sites;
      });
    }
    /*
     * Reload sites mutliple times, because sometimes updates to list of sites
     * aren't ready immediately.
     */
    // Reload sites immediately.
    reload();
    // Reload sites again after 5 seconds.
    setTimeout(reload, 1000 * 5);
    // Reload sites again after 15 seconds.
    setTimeout(reload, 1000 * 15);
  }
827667
function Refresh(Phreezer $phreezer, $row = null)
	{
		$this->_phreezer = $phreezer;

		if ($row)
        {
            $this->Load($row);
        }

         $this->OnRefresh();
	}
656811
protected function reload()
    {
        $pid = $this->getMasterPid();

        if (!$this->isRunning($pid)) {
            $this->output->writeln('<error>no swoole http server process running.</error>');
            return;
        }

        $this->output->writeln('Reloading swoole http server...');

        $isRunning = $this->killProcess($pid, SIGUSR1);

        if (!$isRunning) {
            $this->output->error('> failure');

            return;
        }

        $this->output->writeln('> success');
    }