Reload file again from storage.
480604
def reload(self):
        
        text = self._read(self.location)
        cursor_position = min(self.buffer.cursor_position, len(text))

        self.buffer.document = Document(text, cursor_position)
        self._file_content = text
862237
def reload(self, encoding):
        
        assert os.path.exists(self.path)
        self.open(self.path, encoding=encoding,
                  use_cached_encoding=False)
50865
def reload(self):
        ''''''
        other = type(self).get(self.name, service=self.service)
        self.request_count = other.request_count
1229076
def resume(self):
        ""

        if '_saved' not in vars(self):
            return

        type, exc = map(pickle.loads, self._saved)
        six.reraise(type, exc, self._tb)
108279
public void reload() {

        m_table.init();
        if (!CmsStringUtil.isEmptyOrWhitespaceOnly(m_resourcetypeTableFilter.getValue())) {
            m_table.filterTable(m_resourcetypeTableFilter.getValue());
        }
    }
148471
protected void reload(final boolean forceReload) throws IOException {

        boolean reload = forceReload;
        for (int i = 0; i < locations.length; i++) {
            Resource location = locations[i];
            File file;

            try {
                file = location.getFile();
            } catch (IOException e) {
                // not a file resource
                // may be spring boot
                log.warn(e.toString());
                continue;
            }
            try {
                long l = file.lastModified();

                if (l > lastModified[i]) {
                    lastModified[i] = l;
                    reload = true;
                }
            } catch (Exception e) {
                // cannot access file. assume unchanged.
                if (log.isDebugEnabled()) {
                    log.debug("can't determine modification time of " + file + " for " + location, e);
                }
            }
        }
        if (reload) {
            doReload();
        }
    }
1280513
def reload(self):
        

        result = self._client._get(
            self.__class__.base_url(
                self.sys['id']
            )
        )

        self._update_from_resource(result)

        return self
293826
def reload_me(*args, ignore_patterns=[]):
    """"""
    
    command = [sys.executable, sys.argv[0]]
    command.extend(args)

    reload(*command, ignore_patterns=ignore_patterns)
828615
def resume(self, obj):
        """"""
        if isinstance(obj, str):
            savefile = open(obj, 'rb')
        else:
            savefile = obj
        game = pickle.loads(zlib.decompress(savefile.read()))
        if savefile is not obj:
            savefile.close()
        # Reinstate the random number generator.
        game.random_generator = random.Random()
        game.random_generator.setstate(game.random_state)
        del game.random_state
        return game
1317417
public function reload()
    {
      foreach ($this->data as $idx => $item)
        $this->data[$idx] = $item->reload();
    }
208115
protected void reBuffer()
    {
        resetBuffer();

        try
        {
            int read = buffer.length;
            if (bufferOffset + read > fileLength)
            {
                if (bufferOffset >= fileLength)
                    return;
                read = (int) (fileLength - bufferOffset);
            }

            channel.position(bufferOffset); // setting channel position

            int offset = 0;
            while (read > 0)
            {
                int n = super.read(buffer, offset, read);
                if (n < 0)
                    throw new IllegalStateException();
                read -= n;
                offset += n;
            }

            validBufferBytes = offset;
        }
        catch (IOException e)
        {
            throw new FSReadError(e, filePath);
        }
    }
1029635
public function reload()
    {
        // update application components to the latest version
        if (file_exists($this->lock_file)) {
            unlink($this->lock_file);
        }

        $this->composer = $this->factory->createComposer($this->getIO());
    }
1255347
public void reload() {
        try {
            if (_toplevel.specifics != null) _toplevel.specifics.clear();
            _toplevel.global = null;

            for (T object: _toplevel.retriever.call()) {
                _toplevel.insert(object, _toplevel.coordinates, 0);
            }
            if (_toplevel.global == null) throw new IllegalStateException("***GlobalDataObjectMissing");

            _toplevel.spread();
        } catch (Exception x) {
            throw new RuntimeException(x.getMessage(), x);
        }
    }
110430
function(err) {
      if (!err) {
        loadData(app, apimanager, models, true, uid);
      }
      if (!apimanager.host) {
        //monitor the file changes, load data again if any changes
        fs.watch(definitionsDir, function(event, filename) {
          if (filename !== '.datastore') {
            logger.debug('File changed in %s%s, reload data', definitionsDir, filename);
            loadData(app, apimanager, models, false, uid);
          }
        });
      }
    }
863036
def reload(self):
        
        r = self.api._req_directory(self.cid)
        self.pid = r['pid']
        self.name = r['name']
        self._count = r['count']
209510
def reload(self):
        
        res = self.api._req_file(self.fid)
        data = res['data'][0]
        self.name = data['file_name']
        self.sha = data['sha1']
        self.pickcode = data['pick_code']
134042
def reload(self):
        """"""
        self.restarted_adapter = False
        self.data.clear()
        if conf.use_winpcapy:
            # Reload from Winpcapy
            from scapy.arch.pcapdnet import load_winpcapy
            load_winpcapy()
        self.load()
        # Reload conf.iface
        conf.iface = get_working_if()