{@inheritDoc}

@param entry {@inheritDoc}

@return {@inheritDoc}

@throws CouldNotPerformException {@inheritDoc}
183340
@Override
    public boolean contains(final ENTRY entry) throws CouldNotPerformException {
        if (entry == null) {
            throw new NotAvailableException("entry");
        }
        return contains(entry.getId());
    }
602363
private OpenConnection.Property convertToProperty(Map.Entry<String, String> entry) {
        OpenConnection.Property property = new OpenConnection.Property();
        property.setName(entry.getKey());
        property.setValue(entry.getValue());
        return property;
    }
287093
private int heapifyUp(HeapEntry<E> entry) {
    int numSwaps = 0;
    while (true) {
      if (entry.index == 0) {
        break;
      }
      HeapEntry<E> parentEntry = parent(entry);
      if (compare(entry, parentEntry) >= 0) {
        break;
      }
      numSwaps++;
      swap(entry, parentEntry);
    }
    return numSwaps;
  }
1349497
static <K, V> Map.Entry<K, V> exportEntry(final OMVRBTreeEntry<K, V> omvrbTreeEntryPosition) {
    return omvrbTreeEntryPosition == null ? null : new OSimpleImmutableEntry<K, V>(omvrbTreeEntryPosition);
  }
923024
public static <K, V> Predicate<Map<K, V>> anyEntry(
      Predicate<? super Map.Entry<K, V>> p) {
    return forEntries(Predicates.<Map.Entry<K, V>>any(p));
  }
283643
public int delDependencyEntry(Object id,
                                  Object entry) {
        int returnCode = NO_EXCEPTION;
        if (!this.disableDependencyId) {
            if (delayOffload) {
                Result result = auxDataDependencyTable.removeEntry(id, entry);
                returnCode = result.returnCode;
                if (!result.bExist && returnCode != DISK_EXCEPTION) {
                    returnCode = delValueSetEntry(DEP_ID_DATA, id, entry);
                }
            } else {
                returnCode = delValueSetEntry(DEP_ID_DATA, id, entry);
            }
        }
        return returnCode;
    }
389178
public static <K,V> Entry<K,V> kv(final K key, final V val) {
		return new SerializableEntry<>(key, val);
	}
1365887
@Override
    public Object process(InvocableMap.Entry entry) {
        Object value = entry.getValue();
        return condition.evaluate(value) ? value : null;
    }
812079
@Override
    public boolean accept( final AuditLogEntry entry ) {
        if ( !acceptedTypes.containsKey( entry.getGenericType() ) ) {
            return false;
        }
        return acceptedTypes.get( entry.getGenericType() );
    }
756169
protected ValidationPlanResult validateEntry(Object entry) throws ValidationEngineException
	{

		ValidationPlanResult planResult = new ValidationPlanResult();

		String id = entry.toString();
		if (id == null)
		{
			id = "*";
		}

		printMessage(	id + ", ",LOG_LEVEL_ALL);
		switch(fileType)
		{
		case EMBL:
		case GENBANK:
		case FASTA:
			planResult = emblValidator.execute(entry); 
			break;
		case GFF3:
			planResult = gff3Validator.execute(entry);
			break;
		default:
			break;
						
		}
		return planResult;
	}
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;
    }
54851
public static Map.Entry<String, Map<String, ?>> getSupportedPerformanceDataTypesCommand() {
        return new AbstractMap.SimpleEntry<>(GET_SUPPORTED_PERFORMANCE_DATA_TYPES, ImmutableMap.of());
    }
1121512
public Object process(InvocableMap.Entry entry) {
        Object oldValue = fReturnOld ? entry.getValue() : null;
        entry.remove(false);
        return oldValue;
    }
483359
private TreeEntry<E> getEntry(Entry<?> entry) {
        TreeEntry<E> t = root;
        while (t != null) {
            int cmp = compareLongs(getLow(entry), t.low);
            if (cmp == 0)
                cmp = compareLongs(getHigh(entry), t.high);
            if (cmp == 0)
                cmp = entry.hashCode() - t.value.hashCode();

            if (cmp < 0) {
                t = t.left;
            } else if (cmp > 0) {
                t = t.right;
            } else {
                return t;
            }
        }

        return null;
    }
1326908
static <K, V> TerminalEntry<K, V> entryOf(K key, V value) {
    return new TerminalEntry<K, V>(key, value);
  }
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;
    }
1084149
public EntryBuffer append(Entry entry) {
    int offset = offset(entry.getIndex());
    Entry oldEntry = buffer[offset];
    buffer[offset] = entry.acquire();
    if (oldEntry != null) {
      oldEntry.release();
    }
    return this;
  }