Commits the current edit saving all pending changes on Google Play
169302
def commit_current_edit!
      ensure_active_edit!

      call_google_api { client.commit_edit(current_package_name, current_edit.id) }

      self.current_edit = nil
      self.current_package_name = nil
    end
1157547
def commit(self):
        '''
        

        '''
        url = self.api_endpoints['send']
        payload = {
            'actions': self._bulk_query,
        }
        payload.update(self._payload)
        self._bulk_query = []

        return self._make_request(
            url,
            json.dumps(payload),
            headers={'content-type': 'application/json'},
        )
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()
237282
public function commit(): void
    {
        if (null !== $this->changes) {
            $this->commitInternal($this->changes);

            $this->changes = null;
        }
    }
1206496
@Override
    public void actionCommit() {

        List<Throwable> errors = new ArrayList<Throwable>();

        try {
            // set the synchronize settings
            CmsUserSettings userSettings = new CmsUserSettings(getCms());
            m_synchronizeSettings.checkValues(getCms());
            userSettings.setSynchronizeSettings(m_synchronizeSettings);
            userSettings.save(getCms());
            setDialogObject(null);
        } catch (Throwable t) {
            errors.add(t);
        }

        // set the list of errors to display when saving failed
        setCommitErrors(errors);
    }
715582
function commit() {
            _spork('git', ['commit', '-m', 'Bumping to version ' + require(pkg).version], push,
                _.partial(fulfill, 'Could not commit \'' + chalk.cyan('package.json') + '\''));
          }
781759
void commit(CallInfo callInfo) {
    access(callInfo, () -> {
      logSetup(callInfo);
      clearSavePointIfSet();
      connection.commit();
      return 0;
    });
  }
286088
def commit(self):
		
		try:
			if self.connection is not None:
				self.connection.commit()
				self._updateCheckTime()
				self.release()
		except Exception, e:
			pass
901552
public function commit() : void
    {
        $this->eventDispatcher->dispatchPreFlush();

        if ($this->objectsToPersist === [] &&
            $this->objectsToUpdate === [] &&
            $this->objectsToRemove === []
        ) {
            return; // Nothing to do.
        }

        $objects = array_merge(
            $this->objectsToPersist,
            $this->objectsToUpdate,
            $this->objectsToRemove
        );
        $this->eventDispatcher->dispatchPreFlushLifecycleCallbacks($objects);

        $this->eventDispatcher->dispatchOnFlush();

        $this->persister->executePersists();
        $this->persister->executeUpdates();
        $this->persister->executeRemoves();

        $this->eventDispatcher->dispatchPostFlush();

        $this->objectsToPersist = [];
        $this->objectsToUpdate  = [];
        $this->objectsToRemove  = [];
        $this->objectChangeSets = new ChangeSets();
    }
1230373
public function commit()
    {
        $this->driver->inTransaction(
            function (Driver $driver, array $pendingQueries) {
                /** @var PendingQuery[] $pendingQueries */
                foreach ($pendingQueries as $item) {
                    $item->execute();
                }
            },
            $this->pendingQueries
        );
        $this->pendingQueries = [];
    }
1075851
private void persistCommitChanges(JPACommit commit, Long timestamp) {
        commit.setTimestamp(timestamp);
        addModifiedObjectsToEntityManager(commit.getJPAObjects(), timestamp);
        commit.setCommitted(true);
        logger.debug("persisting JPACommit");
        entityManager.persist(commit);
        logger.debug("mark the deleted elements as deleted");
        updateDeletedObjectsThroughEntityManager(commit.getDeletions(), timestamp);
    }
145570
public void commit() throws IOException, AppPlatformException {
        final Map<String, Object> params = new HashMap<String, Object>();

        params.put("bridgeAudio", isBridgeAudio());
        final String[] callIds = getCallIds();
        params.put("callIds", callIds == null ? Collections.emptyList() : Arrays.asList(callIds));

        client.post(getUri(), params);
    }
261961
public void postUpdate()
    {
        if (current != null)
        {
            final Class<? extends State> next = current.checkTransitions(last);
            if (next != null)
            {
                changeState(next);
            }
        }
    }
638439
def commit(self):  # pylint: disable=no-self-use
        """"""
        if self._config_changed:
            self._last_working_config = self._download_running_config()
            self._config_history.append(self._last_working_config)
            self._committed = True  # comfiguration was committed
            self._config_changed = False  # no changes since last commit :)
            return True  # this will be always true
            # since the changes are automatically applied
        self._committed = False  # make sure the _committed attribute is not True by any chance
        return False
37228
@TargetApi(Build.VERSION_CODES.GINGERBREAD)
    public void apply() {
        if (editing == null) {
            return;
        }
        try {
            editing.apply();
        } catch (Exception ex) {
            editing.commit(); // Fallback in case low api lever.
        }
        editing = null;
    }
278329
def mark_for_update(self):
        '''
            
        '''
        self.pub_statuses.exclude(status=UNPUBLISHED).update(status=NEEDS_UPDATE)
        push_key.delay(self)
594093
def commit(self):
        """"""
        if (not self._add_cache and
                not self._remove_cache and
                not self._undefined_cache):
            return

        for store_key, hash_values in self._add_cache.items():
            for hash_value in hash_values:
                super(TransactionalIndex, self).add_hashed_value(
                    hash_value, store_key)
        for store_key in self._remove_cache:
            super(TransactionalIndex, self).remove_key(store_key)
        for store_key in self._undefined_cache:
            super(TransactionalIndex, self).add_undefined(store_key)
        if not self.ephemeral:
            self.save_to_store()

        self._init_cache()
        self._in_transaction = True