If the entry is a recurrence (see {@link #recurrenceProperty()}) then
this property will store a reference to the entry for which the
recurrence was created.

@return the entry that was the source of the recurrence
164459
public final ReadOnlyObjectProperty<Entry<T>> recurrenceSourceProperty() {
        if (recurrenceSource == null) {
            recurrenceSource = new ReadOnlyObjectWrapper<Entry<T>>(this, "recurrenceSource") { //$NON-NLS-1$
                @Override
                public void set(Entry<T> newEntry) {
                    super.set(newEntry);
                    if (newEntry != null) {
                        setRecurrence(true);
                    } else {
                        setRecurrence(false);
                    }
                }
            };
        }

        return recurrenceSource.getReadOnlyProperty();
    }
838905
public Map.Entry<K, V> getEntry(Object key) {
    EntryImpl<K, V> entry = _entries[keyHash(key) & _mask];
    while (entry != null) {
      if (key.equals(entry._key)) { return entry; }
      entry = entry._next;
    }
    return null;
  }
978667
public boolean get(int entry) {
        if (entry > numEntries || entry < 0)
            throw new ND4JIllegalStateException(
                            "Entry index given (" + entry + ")in is higher then configured one (" + numEntries + ")");

        return (this.holder & 1 << (entry + 1)) != 0;
    }
195194
public synchronized TreeEntry<K, V> pollFirstEntry() {
		final TreeEntry<K, V> entry = firstEntry();
		if (entry != null) {
			remove(entry.getKey());
		}
		return entry;
	}
1151779
public ServiceReference<T> getHighestRankedReference() {
        Iterator<ConcurrentServiceReferenceElement<T>> iterator = elementSet.iterator();
        return iterator.hasNext() ? iterator.next().getReference() : null;
    }
738406
V getLiveValue(ReferenceEntry<K, V> entry) {
    if (entry.getKey() == null) {
      return null;
    }
    V value = entry.getValueReference().get();
    if (value == null) {
      return null;
    }

    if (expires() && isExpired(entry)) {
      return null;
    }
    return value;
  }
525195
public synchronized TreeEntry<K, V> pollLastEntry() {
		final TreeEntry<K, V> entry = lastEntry();
		if (entry != null) {
			remove(entry.getKey());
		}
		return entry;
	}
446504
public Record getReference()
    {
        Record record = this.getReferenceRecord();
        if (record != null)
        {
            try   {
                if (this.getData() == null)
                {
                    record.addNew();
                    return record;
                }
                Object bookmark = this.getData();
                if ((record.getEditMode() == Constants.EDIT_IN_PROGRESS)
                    || (record.getEditMode() == Constants.EDIT_CURRENT))
                {
                    Object oldBookmark = record.getHandle(DBConstants.BOOKMARK_HANDLE);
                    if ((bookmark != null) && (bookmark.equals(oldBookmark)))
                        return record;  // This record is already current
                }
                record.setHandle(bookmark, DBConstants.BOOKMARK_HANDLE);
            } catch (DBException ex)    {
                ex.printStackTrace();
                record = null;
            }   
        } 
        return record;
    }
825627
public OMVRBTreeEntry<K, V> getFirstInMemory() {
    OMVRBTreeEntry<K, V> node = this;
    OMVRBTreeEntry<K, V> prev = this;

    while (node != null) {
      prev = node;
      node = node.getPreviousInMemory();
    }

    return prev;
  }
676418
@Override
    public Object get() {

        Object oObject = null;

        synchronized (this) {
            // Check if any are free in the free hashtable
            if (lastEntry > -1) {
                // Free array has entries, get the last one.
                // remove last one for best performance
                oObject = free[lastEntry];
                free[lastEntry] = null;
                if (lastEntry == firstEntry) { // none left in pool
                    lastEntry = -1;
                    firstEntry = -1;
                } else if (lastEntry > 0) {
                    lastEntry = lastEntry - 1;
                } else { // last entry = 0, reset to end of list
                    lastEntry = poolSize - 1;
                }
            }
        }
        if (oObject == null && factory != null) {
            oObject = factory.create();
        }

        return oObject;
    }
263687
final Entry<K, V> getEntry(Object key) {
	int hash = (key == null) ? 0 : hash(key);
	for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
	    if (e.hash == hash && ((e.key) == key || (key != null && key.equals(e.key)))) return e;
	}
	return null;
    }
956630
@Override
	public OMVRBTreeEntryMemory<K, V> getNextInMemory() {
		OMVRBTreeEntryMemory<K, V> t = this;
		OMVRBTreeEntryMemory<K, V> p = null;

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

		return p;
	}
783948
@Override public ImmutableSet<Entry<K, V>> entries() {
    ImmutableSet<Entry<K, V>> result = entries;
    return (result == null)
        ? (entries = new EntrySet<K, V>(this))
        : result;
  }
520551
public com.ibm.websphere.cache.CacheEntry getEntry(Object id) {
        return getEntry(id, CachePerf.LOCAL, IGNORE_COUNTING, !INCREMENT_REFF_COUNT);
    }
565819
public synchronized Entry current()
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "current");

    checkEntryParent();
      
    if (tc.isEntryEnabled())
      SibTr.exit(tc, "current", current);

    return current;
  }
725014
public static Integer getDurationUnits(RecurringTask recurrence)
   {
      Duration duration = recurrence.getDuration();
      Integer result = null;

      if (duration != null)
      {
         result = UNITS_MAP.get(duration.getUnits());
      }

      return (result);
   }
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;
	}