Commits the changes for all the items in the tree.
        
        :return     <bool> | success
6434
def commit(self):
        
        remove_items = []
        commit_items = []
        
        # remove all the items
        commit_state = XOrbRecordItem.State.Modified | XOrbRecordItem.State.New
        remove_state = XOrbRecordItem.State.Removed
        for i in range(self.topLevelItemCount()):
            item = self.topLevelItem(i)
            
            if isinstance(item, XOrbRecordItem) or\
                isinstance(item, XOrbGroupItem):
                remove_items += item.findItemsByState(remove_state)
                commit_items += item.findItemsByState(commit_state)
        
        # make sure we can remove the records
        for item in remove_items:
            record = item.record()
            try:
                record.remove(dryRun = True, throw=True)
            except orb.errors.CannotRemoveError, err:
                QMessageBox.information(self,
                                        'Cannot Remove',
                                        nativestring(err))
                return False
        
        # remove the records
        remove_set = RecordSet([item.record() for item in remove_items])
        remove_set.remove()
        
        for item in remove_items:
            item.record().remove()
            parent = item.parent()
            if parent:
                index = parent.indexOfChild(item)
                parent.takeChild(index)
            else:
                index = self.indexOfTopLevelItem(item)
                self.takeTopLevelItem(index)
        
        # commit the new records
        for item in commit_items:
            self.aboutToSaveRecord.emit(item.record())
            item.record().commit()
            item.setRecordState(XOrbRecordItem.State.Normal)
        
        self.recordsCommitted.emit()
        
        return True
762016
public function commit()
    {
        // Save deferred items
        $deferredItems = $this->getDeferredItems();

        foreach ($deferredItems as $deferredItem) {
            $this->save($deferredItem);
        }
    }
426506
def commit_all(self):
        """"""
        while self._transaction_nesting_level != 0:
            if not self._auto_commit and self._transaction_nesting_level == 1:
                return self.commit()
            self.commit()
1109771
def commit(self):
        '''
        
        '''
        providen, provstack = get()
        wasnew = (providen is None)
        if wasnew:
            providen = self.getProvIden(provstack)
            setiden(providen)
        return wasnew, s_common.ehex(providen), provstack
1336043
public function commit()
  {
    if (!is_null($this->_changes)) {
      $this->_commit($this->_changes);

      $this->_changes = null;
    }
  }
185492
def commit(self):
        
        self.query.globl['branch'] = self._obranch
        self.query.globl['turn'] = self._oturn
        self.query.globl['tick'] = self._otick
        set_branch = self.query.set_branch
        for branch, (parent, turn_start, tick_start, turn_end, tick_end) in self._branches.items():
            set_branch(branch, parent, turn_start, tick_start, turn_end, tick_end)
        turn_end = self._turn_end
        set_turn = self.query.set_turn
        for (branch, turn), plan_end_tick in self._turn_end_plan.items():
            set_turn(branch, turn, turn_end[branch], plan_end_tick)
        if self._plans_uncommitted:
            self.query.plans_insert_many(self._plans_uncommitted)
        if self._plan_ticks_uncommitted:
            self.query.plan_ticks_insert_many(self._plan_ticks_uncommitted)
        self.query.commit()
        self._plans_uncommitted = []
        self._plan_ticks_uncommitted = []
286088
def commit(self):
		
		try:
			if self.connection is not None:
				self.connection.commit()
				self._updateCheckTime()
				self.release()
		except Exception, e:
			pass
458267
def commit(self):
        """"""
        self.flush()
        if hasattr(self, 'transaction') and self.transaction.is_active:
            self.transaction.commit()
        elif hasattr(self, 'connection'):
            self.connection.commit()
842109
public function commit()
    {
        $this->commiting = true;

        foreach ($this->differed as $key => $item) {
            $this->save($item);

            if ($item->isHit()) {
                unset($this->differed[$key]);
            }
        }

        $result = !count($this->differed);

        $this->commiting = false;

        return $result;
    }
669851
public final void commit() {
        ensureNotYetCreated();
        ensureHasChanges();
        alreadyCreated = true;
        area.replaceMulti(Collections.unmodifiableList(list));
    }
848239
private void commitContexts(boolean accept, boolean all) {
        Stack<IManagedContext<?>> stack = commitStack;
        commitStack = new Stack<>();
        // First, commit or cancel all pending context changes.
        for (IManagedContext<?> managedContext : stack) {
            if (managedContext.isPending()) {
                managedContext.commit(accept);
            }
        }
        // Then notify subscribers of the changes.
        while (!stack.isEmpty()) {
            stack.pop().notifySubscribers(accept, all);
        }
    }
621523
def update(self, key_vals=None, overwrite=True):
        
        if not key_vals:
            return
        write_items = self._update(key_vals, overwrite)
        self._root._root_set(self._path, write_items)
        self._root._write(commit=True)
887328
def update_tree(root, executed_acts, total_rew):
    
    root.value = max(total_rew, root.value)
    root.visits += 1
    new_nodes = 0

    node = root
    for step, act in enumerate(executed_acts):
        if act not in node.children:
            node.children[act] = Node()
            new_nodes += 1
        node = node.children[act]
        node.value = max(total_rew, node.value)
        node.visits += 1

    return new_nodes
296987
def commit(self):
        """"""
        self.git.add('-A', '.')
        try:
            self.git.commit('-m', self.commit_msg)
            return True
        except sh.ErrorReturnCode_1:
            return False
472646
function() {
			this._commitUndo();
			var change, result = false;
			this._ignoreUndo = true;
			do {
				if (this.index >= this.stack.length) {
					break;
				}
				change = this.stack[this.index++];
			} while (!(result = change.redo(this.view, true)));
			this._ignoreUndo = false;
			return result;
		}
1040295
def update(self, commit=True, **kwargs):
        

        for (attr, value) in kwargs.iteritems():
            setattr(self, attr, value)
        return commit and self.save() or self
775571
public function commit()
    {
        // First we validate if every property has a handler
        foreach ($this->mutations as $propertyName => $value) {
            if (!isset($this->result[$propertyName])) {
                $this->failed = true;
                $this->result[$propertyName] = 403;
            }
        }

        foreach ($this->propertyUpdateCallbacks as $callbackInfo) {
            if ($this->failed) {
                break;
            }
            if (is_string($callbackInfo[0])) {
                $this->doCallbackSingleProp($callbackInfo[0], $callbackInfo[1]);
            } else {
                $this->doCallbackMultiProp($callbackInfo[0], $callbackInfo[1]);
            }
        }

        /*
         * If anywhere in this operation updating a property failed, we must
         * update all other properties accordingly.
         */
        if ($this->failed) {
            foreach ($this->result as $propertyName => $status) {
                if (202 === $status) {
                    // Failed dependency
                    $this->result[$propertyName] = 424;
                }
            }
        }

        return !$this->failed;
    }