Apply AddSyncPoint entry and journal the entry.
@param context journal context
@param entry addSyncPoint entry
333112
public void applyAndJournal(Supplier<JournalContext> context, AddSyncPointEntry entry) {
    try {
      apply(entry);
      context.get().append(Journal.JournalEntry.newBuilder().setAddSyncPoint(entry).build());
    } catch (Throwable t) {
      ProcessUtils.fatalError(LOG, t, "Failed to apply %s", entry);
      throw t; // fatalError will usually system.exit
    }
  }
516489
public void add(Object dependency, Object entry) {  //SKS-O
		if (tc.isDebugEnabled())
			Tr.debug(tc, "IMPORTANT: adding dependency " + dependency + " --> " + entry);
		if (dependency == null) {
			throw new IllegalArgumentException("dependency cannot be null");
		}
		ValueSet valueSet = (ValueSet) dependencyToEntryTable.get(dependency);

		if (valueSet == null) {
			valueSet = new ValueSet(4);
			dependencyToEntryTable.put(dependency, valueSet);
		}
		valueSet.add(entry);
	}
199628
@Override
    public void add(QueryableEntry entry) {
        if (++resultSize > resultLimit) {
            throw new QueryResultSizeExceededException();
        }

        rows.add(orderAndLimitExpected ? entry : convertEntryToRow(entry));
    }
1108707
public void addToNavigation(CmsClientSitemapEntry entry) {

        entry.setInNavigation(true);
        CmsSitemapChange change = new CmsSitemapChange(entry.getId(), entry.getSitePath(), ChangeType.modify);
        CmsPropertyModification mod = new CmsPropertyModification(
            entry.getId(),
            CmsClientProperty.PROPERTY_NAVTEXT,
            entry.getTitle(),
            true);
        change.setPropertyChanges(Collections.singletonList(mod));
        change.setPosition(entry.getPosition());
        commitChange(change, null);
    }
1314711
public void addEntry(PartnerLogData logData) {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "addEntry", logData);

        _pltWriteLock.lock();

        try {
            addPartnerEntry(logData);
        } finally {
            _pltWriteLock.unlock();
        }

        if (tc.isEntryEnabled())
            Tr.exit(tc, "addEntry");
    }
626007
private void putEntry(String key, CacheHeader entry) {
        if (!mEntries.containsKey(key)) {
            mTotalSize += entry.size;
        } else {
            CacheHeader oldEntry = mEntries.get(key);
            mTotalSize += (entry.size - oldEntry.size);
        }
        mEntries.put(key, entry);
    }
51476
public final void addBin(@NotNull final BinClasspathEntry entry) {
        Contract.requireArgNotNull("entry", entry);
        if (binList == null) {
            binList = new ArrayList<>();
        }
        binList.add(entry);
    }
1279106
@Override
    public void add(Statement st, Resource... contexts) throws RepositoryException {
        add(st.getSubject(), st.getPredicate(), st.getObject(), mergeResource(st.getContext(), contexts));
    }
503089
public void addEntry(String key, String type, String widget, String params, String optional) {

        m_entries.add(new CmsWorkplaceUserInfoEntry(key, type, widget, params, optional));
    }
1030061
public <R extends Request<T>> R setCacheEntry(Cache.Entry entry) {
        cacheEntry = entry;
        return (R) this;
    }
647742
def add_entry(self, **kw):
        
        self.data.setdefault('entries', []).append(
            {'{}_entry'.format(self.typeof): kw})
1311563
public long applyAndJournal(Supplier<JournalContext> context, NewBlockEntry entry) {
    try {
      long id = applyNewBlock(entry);
      context.get().append(JournalEntry.newBuilder().setNewBlock(entry).build());
      return id;
    } catch (Throwable t) {
      ProcessUtils.fatalError(LOG, t, "Failed to apply %s", entry);
      throw t; // fatalError will usually system.exit
    }
  }
1271391
def _add_entry (self, entry):
        
        if "*" in entry.useragents:
            # the default entry is considered last
            self.default_entry = entry
        else:
            self.entries.append(entry)
447097
public int writeTemplateEntry(String template,
                                  Object entry) {
        int rc = NO_EXCEPTION;
        if (!this.disableTemplatesSupport) {
            if (delayOffload) {
                ValueSet vs = auxTemplateDependencyTable.getEntries(template);
                if (vs == null) {
                    Result result = writeValueSetEntry(TEMPLATE_ID_DATA, template, entry, null, !ADD_IF_NEW);
                    rc = result.returnCode;
                    boolean bExist = result.bExist;
                    returnToResultPool(result);
                    if (rc != DISK_EXCEPTION && rc != DISK_SIZE_OVER_LIMIT_EXCEPTION && bExist == !EXIST) {
                        rc = auxTemplateDependencyTable.add(template, entry);
                    }
                } else {
                    rc = auxTemplateDependencyTable.add(template, vs, entry);
                }
            } else {
                Result result = writeValueSetEntry(TEMPLATE_ID_DATA, template, entry, null, ADD_IF_NEW);
                rc = result.returnCode;
                returnToResultPool(result);
            }
        }
        return rc;
    }
403745
public synchronized void add(Runnable runnable) {
    if (head == null) {
      head = new Entry(runnable);
    } else {
      Entry parent = head;
      while (parent.next != null) {
        parent = parent.next;
      }
      parent.next = new Entry(runnable);
    }
  }
779297
public void insertSubEntry(CmsClientSitemapEntry entry, int position, I_CmsSitemapController controller) {

        entry.updateSitePath(CmsStringUtil.joinPaths(m_sitePath, entry.getName()), controller);
        m_subEntries.add(position, entry);
        updatePositions(position);
    }
59236
public void applyAndJournal(Supplier<JournalContext> context, DeleteFileEntry entry) {
    // Unlike most entries, the delete file entry must be applied *before* making the in-memory
    // change. This is because delete file and create file are performed with only a read lock on
    // the parent directory. As soon as we do the in-memory-delete, another thread could re-create a
    // directory with the same name, and append a journal entry for the inode creation. This would
    // ruin journal replay because we would see two create file entries in a row for the same file
    // name. The opposite order is safe. We will never append the delete entry for a file before its
    // creation entry because delete requires a write lock on the deleted file, but the create
    // operation holds that lock until after it has appended to the journal.
    try {
      context.get().append(JournalEntry.newBuilder().setDeleteFile(entry).build());
      applyDelete(entry);
    } catch (Throwable t) {
      // Delete entries should always apply cleanly, but if it somehow fails, we are in a state
      // where we've journaled the delete, but failed to make the in-memory update. We don't yet
      // have a way to recover from this, so we give a fatal error.
      ProcessUtils.fatalError(LOG, t, "Failed to apply entry %s", entry);
    }
  }