Commit the newly created elements into the original Subject.
480004
protected void setUpSubject() throws WSLoginFailedException {
        try {
            AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
                @Override
                public Object run() throws Exception {
                    updateSubjectWithTemporarySubjectContents();
                    return null;
                }
            });
        } catch (PrivilegedActionException e) {
            throw new WSLoginFailedException("Unable to setup the Subject: " + e.getLocalizedMessage());
        }
    }
796470
def to_commit(obj):
    """"""
    if obj.type == 'tag':
        obj = deref_tag(obj)

    if obj.type != "commit":
        raise ValueError("Cannot convert object %r to type commit" % obj)
    # END verify type
    return obj
414286
def prepend_elements(self, elements):
        
        self._elements = list(elements) + self._elements
        self._on_element_change()
1311009
public void commit() throws IOException {
        // assures we perform the close operation only once.
        if (open.compareAndSet(true, false)) {
            // flush & close
            fout.force(true);
            fout.close();

            // if the current file exists, and append is true, then append samples and remove temp file
            // otherwise write header and move tmp file to target
            boolean exists = Files.exists(target);
            if (logger.isInfoEnabled()) {
                logger.info("Finishing recording ...... append: " + append + " exists: " + exists + " target:" + target);
            }
            if (append && exists) {
                appendSamples(target, temp);
                writeHeader(target);
                Files.delete(temp);
            } else {
                writeHeader(temp);
                Files.move(temp, target, StandardCopyOption.REPLACE_EXISTING);
            }
        }
    }
370003
void commit() {
    if (committed) {
      errorManager.logError("Committed the fragment for %s twice.", fragmentPackageName);
      return;
    }

    committed = true;

    // Write the field where the enclosing injector is stored.
    writer.beginJavaDocComment();
    writer.print("Field for the enclosing injector.");
    writer.endJavaDocComment();
    writer.println("private final %s injector;", ginjectorClassName);

    // Write the constructor, which takes the enclosing injector and does
    // nothing but store it in a field.  It's important that the constructor has
    // no other side-effects; in particular, it must not call any injector
    // methods, since the injector might not be fully constructed.
    sourceWriteUtil.writeMethod(writer,
        String.format("public %s(%s injector)", fragmentClassName, ginjectorClassName),
        "this.injector = injector;");

    if (hasEagerSingletonInitialization()) {
      // Write a method to initialize eager singletons.
      sourceWriteUtil.writeMethod(
          writer,
          "public void initializeEagerSingletons()",
          initializeEagerSingletonsBody.toString());
    }

    if (hasStaticInjectionInitialization()) {
      // Write a method to initialize static injection.
      sourceWriteUtil.writeMethod(
          writer,
          "public void initializeStaticInjections()",
          initializeStaticInjectionsBody.toString());
    }

    writer.commit(logger);
  }
573027
def _insert_defaults(self):
        
        merged = merge_defaults(self.structure, self)
        self.update(merged)
229809
public final void commit() {
        if (indexQueue == null) {
            luceneIndex.commit();
        } else {
            indexQueue.submitSynchronous(new Runnable() {
                @Override
                public void run() {
                    luceneIndex.commit();
                }
            });
        }
    }
1089389
public function commit()
    {
        foreach ($this->registry->all() as $entity) {
            switch($this->getEntityState($entity)) {
                case EntityStates::NEW_ENTITY:
                    $this->commandBus->dispatch(new NewCommand($entity));
                    break;
                case EntityStates::EDITED_ENTITY:
                    $changeSet = $this->changeBuilder->buildChanges($this->registry->getSnapshot($entity), $entity);
                    $this->commandBus->dispatch(new EditCommand($entity, $changeSet));
                    break;
                case EntityStates::REMOVED_ENTITY:
                    $this->commandBus->dispatch(new RemoveCommand($entity));
                    break;
            }
        }

        $this->registry->cleanRemoved();
        $this->registry->makeNewSnapshots();
    }
746176
public void commit()
    {
        long        elapsed = System.nanoTime() - startTimeNanos;
        driver.addTrace(name, elapsed, TimeUnit.NANOSECONDS);
    }
984773
def commit(self):
        """"""
        self.send_buffered_operations()
        retry_until_ok(self.elastic.indices.refresh, index="")
633149
def commit(cls):
        
        cls.objects.deleted().true_delete()
        cls.objects.changed().true_update(_new=False, _changed=False)
1173552
protected function _commit()
    {
        $this->_connect();
        $this->_connection->commit();
        $this->_connection->autocommit(true);
    }
1132208
function commitInternally( targetFields )
		{
			if ( incommit )
				return;

			incommit = 1;

			var dialog = this.getDialog(),
				element = dialog.imageElement;
			if ( element )
			{
				// Commit this field and broadcast to target fields.
				this.commit( IMAGE, element );

				targetFields = [].concat( targetFields );
				var length = targetFields.length,
					field;
				for ( var i = 0; i < length; i++ )
				{
					field = dialog.getContentElement.apply( dialog, targetFields[ i ].split( ':' ) );
					// May cause recursion.
					field && field.setup( IMAGE, element );
				}
			}

			incommit = 0;
		}
745706
def commit(self):
        """"""
        out = open(self.name,'wb')
        cPickle.dump(self.fields,out,self.protocol)
        cPickle.dump(self.next_id,out,self.protocol)
        cPickle.dump(self.records,out,self.protocol)
        cPickle.dump(self.indices,out,self.protocol)
        out.close()
237282
public function commit(): void
    {
        if (null !== $this->changes) {
            $this->commitInternal($this->changes);

            $this->changes = null;
        }
    }
606698
private void commit() {

        m_selectionDone = true;
        if (!m_filesToUpload.isEmpty()) {
            m_okButton.disable(Messages.get().key(Messages.GUI_UPLOAD_BUTTON_OK_DISABLE_UPLOADING_0));
            if (m_uploadButton instanceof UIObject) {
                ((UIObject)m_uploadButton).getElement().getStyle().setDisplay(Display.NONE);
            }
            showProgress();
            submit();
        }
    }
594431
def put(self, key, value, element):
        """"""
        self.neoindex[key][value] = element.neoelement