Marks the nodes with the specified ids as expanded.

@param entry1 the first node
@param entry2 the second node
338597
public void setExpanded(SpatialEntry entry1, SpatialEntry entry2) {
    IntSet exp1 = expanded.get(getPageID(entry1));
    if(exp1 == null) {
      exp1 = new IntOpenHashSet();
      expanded.put(getPageID(entry1), exp1);
    }
    exp1.add(getPageID(entry2));
  }
340351
private void deleteEntry(TreeEntry<E> p) {
        entryIDs.remove(p.value.getId());

        treeSize--;

        // If strictly internal, copy successor's element to p and then make p
        // point to successor.
        if (p.left != null && p.right != null) {
            TreeEntry<E> s = successor(p);
            p.low = s.low;
            p.high = s.high;
            p.value = s.value;
            p.maxHigh = s.maxHigh;
            p = s;
        }      // p has 2 children

        // Start fixup at replacement node, if it exists.
        TreeEntry<E> replacement = p.left != null ? p.left : p.right;

        if (replacement != null) {
            // Link replacement to parent
            replacement.parent = p.parent;
            if (p.parent == null) {
                root = replacement;
            } else if (p == p.parent.left) {
                p.parent.left = replacement;
            } else {
                p.parent.right = replacement;
            }

            // Null out links so they are OK to use by fixAfterDeletion.
            p.left = null;
            p.right = null;
            p.parent = null;

            fixUpMaxHigh(replacement.parent); // augmented interval tree

            // Fix replacement
            if (p.color == BLACK) {
                fixAfterDeletion(replacement);
            }
        } else if (p.parent == null) { // return if we are the only node.
            root = null;
        } else { // No children. Use self as phantom replacement and unlink.
            if (p.color == BLACK) {
                fixAfterDeletion(p);
            }

            if (p.parent != null) {
                if (p == p.parent.left) {
                    p.parent.left = null;
                } else if (p == p.parent.right) {
                    p.parent.right = null;
                }

                fixUpMaxHigh(p.parent); // augmented interval tree

                p.parent = null;
            }
        }
    }
531290
static String encodeEntry(Entry<String, Point2d[]> entry) {
        StringBuilder sb = new StringBuilder();
        sb.append(entry.getKey());
        sb.append(' ');
        sb.append(encodeCoordinates(entry.getValue()));
        return sb.toString();
    }
79796
public void addEntry(String logType, LogEntry entry) {
    if (logTypesToIgnore.contains(logType)) {
      return;
    }

    if (!localLogs.containsKey(logType)) {
      localLogs.put(logType, Lists.newArrayList(entry));
    } else {
      localLogs.get(logType).add(entry);
    }
  }
1361400
public void addDataId(Object dataId) {
	  if (lock == SET) {
		 throw new IllegalStateException("EntryInfo is locked");
	  }
	  if (dataId != null && !dataId.equals("")) {
		  dataIds.add(dataId);
	  }
   }
1292325
@JsonProperty(value = "entries")
    public void setEntries(List<Object> entries) {
        if (entries == null) {
            this.entries = new ArrayList<>();
        } else {
            this.entries = entries;
        }
    }
17245
private static Map<?, ?> mapOfEntries( Entry<?, ?>... entries ) {
        Map<Object, Object> looseTypedMap = new LinkedHashMap<>( entries.length );
        for (Entry<?, ?> entry : entries)
            looseTypedMap.put(entry.getKey(), entry.getValue());
        return looseTypedMap;
    }
1315361
@SuppressWarnings("unchecked")
  public Query linksToEntryId(String entryId) {
    checkNotEmpty(entryId, "entryId must not be empty.");

    params.put(PARAMETER_LINKS_TO_ENTRY, entryId);

    return (Query) this;
  }
17034
public Entries<K, V> entries () {
		if (entries1 == null) {
			entries1 = new OrderedMapEntries(this);
			entries2 = new OrderedMapEntries(this);
		}
		if (!entries1.valid) {
			entries1.reset();
			entries1.valid = true;
			entries2.valid = false;
			return entries1;
		}
		entries2.reset();
		entries2.valid = true;
		entries1.valid = false;
		return entries2;
	}
796119
public void setEntries(List<E> entries) {
        if (entries == null) {
            this.entries = new ArrayList<>();
        } else {
            this.entries = entries;
        }
    }
1261470
def mark(id)
      found = false
      @entries.each do |entry|
        if entry[ID] == id
          entry[MARKED] = 1
          found = true
          break
        end
      end

      unless found
        PEROBS.log.fatal "Cannot find an entry for ID #{'%016X' % id} " +
          "#{id} to mark"
      end

      write_index
    end
716881
public void addition(E entry) {
        if (additions==null) additions = new ArrayList<E>();
        additions.add(entry);
    }
627144
public int writeDependencyEntry(Object id,
                                    Object entry) {
        int rc = NO_EXCEPTION;
        if (!this.disableDependencyId) {
            if (delayOffload) {
                ValueSet vs = auxDataDependencyTable.getEntries(id);
                if (vs == null) {
                    Result result = writeValueSetEntry(DEP_ID_DATA, id, 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 = auxDataDependencyTable.add(id, entry);
                    }
                } else {
                    rc = auxDataDependencyTable.add(id, vs, entry);
                }
            } else {
                Result result = writeValueSetEntry(DEP_ID_DATA, id, entry, null, ADD_IF_NEW);
                rc = result.returnCode;
                returnToResultPool(result);
            }
        }
        return rc;
    }
715392
@Override
  public void addEntry(String logType, LogEntry entry) {
    if (!logTypesToInclude.contains(logType)) {
      return;
    }

    if (!localLogs.containsKey(logType)) {
      List<LogEntry> entries = new ArrayList<>();
      entries.add(entry);
      localLogs.put(logType, entries);
    } else {
      localLogs.get(logType).add(entry);
    }
  }
313156
protected void entry(final String fqcn, final Object... params) {
        if (isEnabled(Level.TRACE, ENTRY_MARKER, (Object) null, null)) {
            if (params == null) {
                logMessageSafely(fqcn, Level.TRACE, ENTRY_MARKER, entryMsg(null, (Supplier<?>[]) null), null);
            } else {
                logMessageSafely(fqcn, Level.TRACE, ENTRY_MARKER, entryMsg(null, params), null);
            }
        }
    }
1062087
private final void offerEntry(ChartEntry entry, double probability, int spanStart, int spanEnd) {
    int nextEntryIndex = chartSizes[spanStart][spanEnd];
    if (nextEntryIndex == chart[spanStart][spanEnd].length) {
      // Resize the arrays to fit the new entry.
      ChartEntry[] spanChart = chart[spanStart][spanEnd];
      double[] spanProbs = probabilities[spanStart][spanEnd];
      chart[spanStart][spanEnd] = Arrays.copyOf(spanChart, spanChart.length * 2);
      probabilities[spanStart][spanEnd] = Arrays.copyOf(spanProbs, spanChart.length * 2);
    }

    chart[spanStart][spanEnd][nextEntryIndex] = entry;
    probabilities[spanStart][spanEnd][nextEntryIndex] = probability;
    chartSizes[spanStart][spanEnd]++;
    totalChartSize++;
  }
1300704
@Override
   protected void entering(NodeData node, int level) throws RepositoryException
   {
      try
      {
         writer.writeStartElement(Constants.NS_SV_PREFIX, Constants.SV_NODE, getSvNamespaceUri());
         if (level == 0)
         {
            startPrefixMapping();
         }

         writer.writeAttribute(Constants.NS_SV_PREFIX, getSvNamespaceUri(), Constants.SV_NAME, getExportName(node,
            false));
      }
      catch (XMLStreamException e)
      {
         throw new RepositoryException(e);
      }

   }