Checks whether an item exist in queue or not.

@param entry item to be checked
@return <code>true</code> if exists, <code>false</code> otherwise
554510
@Override
    public boolean contains(DelayedEntry entry) {
        Data key = (Data) entry.getKey();
        return index.containsKey(key);
    }
1106655
private boolean entryInRefreshProbationAccessed(final Entry<K, V> e, final long now) {
    long  nrt = e.getRefreshProbationNextRefreshTime();
    if (nrt > now) {
      reviveRefreshedEntry(e, nrt);
      return true;
    }
    return false;
  }
402453
public boolean containsKey(int key) {
        Entry tab[] = table;

        int index = (key & 0x7FFFFFFF) % tab.length;
        for (Entry e = tab[index]; e != null; e = e.next) {
            if (e.key == key) {
                return true;
            }
        }
        
        return false;
    }
597438
public boolean add(E entry)
	{
		super.add(entry);
		
		if(this.size() > this.maxSize)
		{
			super.removeRange(0, this.size() - maxSize);
		}
		
		return true;
	}
986471
@Override
    public boolean exists(int row, int column) {
        return row >= 0 && row < rowCount() && column >= 0 && column < columnCount();
    }
1310838
public function isAllowed($entry)
    {
        foreach ($this->entries as $elmt) {
            if ($elmt->check($entry)) {
                return $this->matchingResponse;
            }
        }

        return null;
    }
1314510
public boolean hasDiscriminator() {
        boolean hasDiscriminator = false;

        for (Entry<String, String> entry : _inputs.entrySet()) {
            String key = entry.getKey();

            if (StagingData.STANDARD_LOOKUP_KEYS.contains(key))
                continue;

            String value = entry.getValue();
            if (value != null && !value.isEmpty()) {
                hasDiscriminator = true;
                break;
            }
        }

        return hasDiscriminator;
    }
716881
public void addition(E entry) {
        if (additions==null) additions = new ArrayList<E>();
        additions.add(entry);
    }
470700
boolean isEnqueued(Reference<? extends T> reference) {
        synchronized (lock) {
            return reference.queueNext != null && reference.queueNext != sQueueNextUnenqueued;
        }
    }
1094682
public static boolean hasEntry(Object list) {
        if (list == null)
            return false;
        if (list instanceof List)
            return !((List<?>) list).isEmpty();
        return true;
    }
433485
@Override
    public boolean containsKey(Object key) {
        if (key == null) {
            throw new NullPointerException();
        }
        
        CachedValue<K, V> entry = map.get(key);
        if (entry == null) {
            return false;
        }
        if (isValueExpired(entry)) {
            if (map.remove(key, entry)) {
                onValueRemove(entry);
                return false;
            }
            return containsKey(key);
        }
        return true;
    }
454073
public boolean containsValue(Object value) {
        if (value == null) {
            value = new Null();
        }

        Entry tab[] = mTable;
        
        for (int i = tab.length ; i-- > 0 ;) {
            for (Entry e = tab[i], prev = null; e != null; e = e.mNext) {
                Object entryValue = e.getValue();

                if (entryValue == null) {
                    // Clean up after a cleared Reference.
                    mModCount++;
                    if (prev != null) {
                        prev.mNext = e.mNext;
                    }
                    else {
                        tab[i] = e.mNext;
                    }
                    mCount--;
                }
                else if (value.equals(entryValue)) {
                    return true;
                }
                else {
                    prev = e;
                }
            }
        }

        return false;
    }
24212
function exists (store, key) {
  const entry = store.get(key)
  // checks entry exists and it has not timed-out
  return !!entry && Date.now() - entry.created < entry.ttl
}
241560
private static boolean isNotSREEntry(IRuntimeClasspathEntry entry) {
		try {
			final File file = new File(entry.getLocation());
			if (file.isDirectory()) {
				return !SARLRuntime.isUnpackedSRE(file);
			} else if (file.canRead()) {
				return !SARLRuntime.isPackedSRE(file);
			}
		} catch (Throwable e) {
			SARLEclipsePlugin.getDefault().log(e);
		}
		return true;
	}
1101517
public synchronized boolean isQueueEmpty()
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "isQueueEmpty");
      boolean result = queue.isEmpty();
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "isQueueEmpty", ""+result);
      return result;
   }
4128
public boolean hasMenuEntry(AdminComponent component, MenuEntry activeMenue) {
		if (null != component && null != component.getMainMenu()) {
			Optional<MenuEntry> result = component.getMainMenu().flattened()
					.filter(menu -> checkForNull(menu, activeMenue) ? menu.getName().equals(activeMenue.getName()): false)
					.findFirst();
			return result.isPresent();
		}
		return false;
	}
806604
public boolean containsValue(Object value) {
        Entry tab[] = table;
        
        if (value==null) {
            for (int i = tab.length ; i-- > 0 ;) {
                for (Entry e = tab[i] ; e != null ; e = e.next) {
                    if (e.value == null) {
                        return true;
                    }
                }
            }
        } 
        else {
            for (int i = tab.length ; i-- > 0 ;) {
                for (Entry e = tab[i] ; e != null ; e = e.next) {
                    if (value.equals(e.value)) {
                        return true;
                    }
                }
            }
        }
        
        return false;
    }