Initiate a refresh of the parameter TOC.
353707
def refresh_toc(self, refresh_done_callback, toc_cache):
        
        self._useV2 = self.cf.platform.get_protocol_version() >= 4
        toc_fetcher = TocFetcher(self.cf, ParamTocElement,
                                 CRTPPort.PARAM, self.toc,
                                 refresh_done_callback, toc_cache)
        toc_fetcher.start()
1064358
private void refresh(final ClientMapInfo mapInfo) {
		actualRefresh(mapInfo);
		if (state == State.INITIALIZING) {
			// only change the initial bounds the first time around
			Bbox initialBounds = new Bbox(mapInfo.getInitialBounds());
			mapView.applyBounds(initialBounds, MapView.ZoomOption.LEVEL_CLOSEST);
		}
		state = State.INITIALIZED;
		fireRefreshEvents();
		
		while (whenInitializedRunnables.size() > 0) {
			Runnable runnable = whenInitializedRunnables.remove(0);
			runnable.run();
		}
	}
468045
public static void refresh()
    {
        try
        {
            setContext(prop);
        }
        catch (NamingException e)
        {
            log.error("Unable to refresh the naming context");
            throw new OJBRuntimeException("Refresh of context failed, used properties: "
                    + (prop != null ? prop.toString() : "none"), e);
        }
    }
267394
def refresh(self):
        
        self.invalidate()
        full = not self._manager._list_has_name
        res_list = self._manager.list(full_properties=full)
        self.update_from(res_list)
988854
def request_update_of_all_params(self):
        """"""
        for group in self.toc.toc:
            for name in self.toc.toc[group]:
                complete_name = '%s.%s' % (group, name)
                self.request_param_update(complete_name)
885903
def refresh(self):
        """"""
        self._update_id_list()
        for _id in self.history[:]:
            if _id not in self.id_list:
                self.history.remove(_id)
528634
def refresh(self):
        
        if self.exists:
            self.delete()
        self.populate()
        self.open()
284939
@Override
    public void refresh() {
        String url = mockupTypes.getUrl(mockupType);
        
        if (mockupId == null || url == null) {
            iframe.setSrc(null);
            return;
        }
        
        iframe.setSrc(String.format(url, mockupId, System.currentTimeMillis()));
    }
141500
def do_refresh(self,args):
        """"""
        pprint(AwsConnectionFactory.getEc2Client().describe_network_interfaces(NetworkInterfaceIds=[self.physicalId]));
591736
def refresh(self, **kwargs):
        
        traverse_setter(self, '_force', True)
        key = self.current_key if self.current_key else self.keys[0]
        dim_streams = [stream for stream in self.streams
                       if any(c in self.dimensions for c in stream.contents)]
        stream_params = stream_parameters(dim_streams)
        key = tuple(None if d in stream_params else k
                    for d, k in zip(self.dimensions, key))
        stream_key = util.wrap_tuple_streams(key, self.dimensions, self.streams)

        self._trigger_refresh(stream_key)
        if self.comm is not None and self.top_level:
            self.push()
340910
def refresh_content(self, order=None, name=None):
        
        order = order or self.content.order

        # Preserve the query if staying on the current page
        if name is None:
            query = self.content.query
        else:
            query = None

        name = name or self.content.name

        # Hack to allow an order specified in the name by prompt_subreddit() to
        # override the current default
        if order == 'ignore':
            order = None

        with self.term.loader('Refreshing page'):
            self.content = SubredditContent.from_name(
                self.reddit, name, self.term.loader, order=order, query=query)
        if not self.term.loader.exception:
            self.nav = Navigator(self.content.get)
29296
def refreshLabels( self ):
        
        itemCount = self.itemCount()
        title = self.itemsTitle()
        
        if ( not itemCount ):
            self._itemsLabel.setText(' %s per page' % title)
        else:
            msg = ' %s per page, %i %s total' % (title, itemCount, title)
            self._itemsLabel.setText(msg)
750581
protected function _refresh()
    {
        $this->_statement->execute($this->_params);
        if ($this->_statement->errorCode() !== '00000') {
            throw new DbException($this->_statement->errorInfo(), $this->_statement->queryString);
        }
        $this->_currentRowIndex = 0;
    }
1323722
def refreshDetails( self ):
        
        # start off by filtering based on the group selection
        tree = self.uiRecordsTREE
        tree.blockSignals(True)
        tree.setRecordSet(self.records())
        tree.blockSignals(False)
767320
def do_refresh(self,args):
        """"""
        self.wrappedStack = self.wrapStack(AwsConnectionFactory.instance.getCfResource().Stack(self.wrappedStack['rawStack'].name))
427168
def __refresh(self):
        """"""
        raw_values = self.__get_values()
        if not raw_values:
            raise RefreshException('Point has no values')

        # individual templates
        templates = []
        # lookup tables by type and unit of value
        by_type = {}
        by_unit = {}

        for raw_value in raw_values:
            label = raw_value['label']
            if not valid_identifier(label) or label.startswith('__'):
                raise RefreshException('Value "%s" unsuitable for object wrapper' % label)
            value = Value(label, raw_value['type'], raw_value['unit'], raw_value['comment'])
            templates.append(value)
            try:
                by_type[value.type_].add(label)
            except KeyError:
                by_type[value.type_] = {label}
            if value.unit:
                try:
                    by_unit[value.unit].add(label)
                except KeyError:
                    by_unit[value.unit] = {label}

        self.__value_templates = templates
        self.__filter = _ValueFilter(by_type, by_unit)
150589
def refresh_table(self):
        """"""
        if self.is_visible and self.isVisible():
            self.shellwidget.refresh_namespacebrowser()
            try:
                self.editor.resizeRowToContents()
            except TypeError:
                pass