Save the state of this inference context
354490
public List<Type> save() {
        ListBuffer<Type> buf = new ListBuffer<>();
        for (Type t : undetvars) {
            buf.add(((UndetVar)t).dup(infer.types));
        }
        return buf.toList();
    }
174865
def restore(self, state):
        
        self._clear()
        self._parseUserInfo({'labels': state['labels']})
        self._parseNodes(state['nodes'])
        self._keep_version = state['keep_version']
514600
def save_conditions(self) -> None:
        """"""
        for element in printtools.progressbar(self):
            element.model.sequences.save_conditions()
774990
void saveState(Bundle outState) {
        outState.putString(STATE_CURRENT_PATH, currentPath);
        outState.putSerializable(STATE_FOLDERS, folders);
        outState.putSerializable(STATE_NEXT_TOKENS, nextTokens);
    }
755849
def save(self):
        
        data = super().save()
        data['state_sizes'] = self.state_sizes
        data['reset_on_sentence_end'] = self.reset_on_sentence_end
        return data
358760
def save(self, f):
        """"""
        return pickle.dump((self.perceptron.weights, self.tagdict, self.classes, self.clusters), f, protocol=pickle.HIGHEST_PROTOCOL)
113162
def SaveState( self, config_parser ):
        """"""
        if not config_parser.has_section( 'window' ):
            config_parser.add_section( 'window' )
        if self.IsMaximized():
            config_parser.set( 'window', 'maximized', str(True))
        else:
            config_parser.set( 'window', 'maximized', str(False))
        size = self.GetSizeTuple()
        position = self.GetPositionTuple()
        config_parser.set( 'window', 'width', str(size[0]) )
        config_parser.set( 'window', 'height', str(size[1]) )
        config_parser.set( 'window', 'x', str(position[0]) )
        config_parser.set( 'window', 'y', str(position[1]) )
        
        for control in self.ProfileListControls:
            control.SaveState( config_parser )

        return config_parser
137838
def _save_one(self, model, ctx):
        
        assert isinstance(ctx, ResourceQueryContext)

        self._orm.add(model)
        self._orm.flush()
1262822
def save(self, fp=None):
        
        self.settings['storage'] = {
            'state_separator': self.state_separator
        }
        self.do_save(fp)
817595
static void saveState(Bundle outState) {
        stateKeeper.bundle = outState;
        MvcComponent root = getRootComponent();
        doSaveState(root);

        stateKeeper.bundle = null;
    }
965552
def _saveState(self, path):
        """"""
        self.addSession()  # next session
        self._save(str(self.n_sessions), path)
319358
private void preEncode(FacesContext context) {
        setDataModel(null); // re-evaluate even with server-side state saving
        if (!keepSaved(context)) {
            ////noinspection CollectionWithoutInitialCapacity
            //saved = new HashMap<String, SavedState>();
            getStateHelper().remove(PropertyKeys.saved);
        }
    }
877142
def _save(self):
        
        collection = JSONClientValidated('assessment',
                                         collection='AssessmentSection',
                                         runtime=self._runtime)
        if '_id' in self._my_map:  # This is the first time:
            collection.save(self._my_map)
        else:
            insert_result = collection.insert_one(self._my_map)
            self._my_map = collection.find_one({'_id': insert_result.inserted_id})
44073
void save() {

        saveAndDeleteEntities(false, new I_CmsSimpleCallback<Boolean>() {

            public void execute(Boolean hasChangedSettings) {

                setSaved();
                setUnchanged();
                m_hasChangedSettings = m_hasChangedSettings || hasChangedSettings.booleanValue();
            }
        });
    }
803266
def save(self, reload=False):
        """"""
        self.wrapper.raw.save()
        if reload:
            self.reload()
385031
def save_state(self):
        '''
        
        '''
        self._save_state()
        while self.peek() != simpy.core.Infinity:
            delay = max(self.peek() - self.now, self.interval)
            utils.logger.debug('Step: {}'.format(self.now))
            ev = self.event()
            ev._ok = True
            # Schedule the event with minimum priority so
            # that it executes before all agents
            self.schedule(ev, -999, delay)
            yield ev
            self._save_state()
1050605
def savestate(self, state, chain=-1):
        """"""
        cur_chain = self._chains[chain]
        if hasattr(cur_chain, '_state_'):
            cur_chain._state_[0] = state
        else:
            s = self._h5file.create_vlarray(
                cur_chain,
                '_state_',
                tables.ObjectAtom(),
                title='The saved state of the sampler',
                filters=self.filter)
            s.append(state)
        self._h5file.flush()